tomcat配置和连接池原理
tomcat 6.0如何配置虚拟目录?tomcat 6.0 不能列目录?
一、具体配置方法如下：
找到TOMCAT的安装目录，再打开conf目录下的server.xml.
将元素
D:\testservlet为实际目录，而/testservlet为虚拟目录，在地址栏敲入
http://localhost:8080/testservlet
实际访问的目录为D:\testservlet，我们给D:\testservlet做了一个映射。
二、问题描述：
以前的tomcat 5.5时比如说当访问目录test时，它会把test目录下的文件列出来，但是在tomcat 6.0中就提示没有！要把全名输入了才行,如http://locahost/test/tes.jsp才能正常显示，
但如果是http://localhost/test它就提示没有，这是不是配置上的问题！或者是6.0故意这样做的？
三、解决方案：
5.5的也是关闭了目录浏览功能的，你说的应该是5.0的，这个主要是处于安全性的考虑。要是你的目录下没有默认首页，那你的这个目录下的文件列表就泄露给别人了。
这个是个配置选项，你可以手动打开，开发时有用，但是生产环境就最好关闭。
配置选项在TOMCAT/conf/web.xml中找到
将其中的
设置改为true即可解决此问题
Tomcat6.0连接池配置
1.Tomcat6.0连接池配置
2.1.配置tomcat下的conf下的server.xml中的host标签中添加连接池
配置:
3. reloadable="true" crossContext="true"> 4.1. 5.2. auth="Container" 6.3. type="javax.sql.DataSource" 7.4. driverClassName="com.microsoft.jdbc.sqlserver.SQLSe rverDriver" 8.5. url=" jdbc:microsoft:sqlserver://localhost:1433;databasename=hrms" 9.6. username="sa" 10.7. password="123456" 11.8. maxActive="100" 12.9. maxIdle="30" 13.10. maxWait="10000" /> 14. 15.2.配置你的应用下的web.xml中的web-app标签之间加入: 16.1. 17.2. 18.3. 19.4. 20.5. 21.6. 22.3.把连接数据库的第三方驱动放到common/lib下面就ok了 23.4.测试程序我就不写了 24. 25.Tomcat5.5x连接池配置 26. 27.方式一、全局数据库连接池 28.1、通过管理界面配置连接池，或者直接在tomcat\conf\server.xml的 GlobalNamingResources中增加 29. password="mypwd" driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver" maxIdle="2" maxWait="5000" validationQuery="select 1" username="sa" url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb" maxActive="4"/> 30.2、在tomcat\webapps\myapp\META-INF\context.xml的Context中增 加： 31. type="javax.sql.DataSource"/> 32.这样就可以了。 33.方式二、全局数据库连接池 34.1、同上 35.2、在tomcat\conf\context.xml的Context中增加： 36. type="javax.sql.DataSource"/> 37.方式三、局部数据库连接池 38.只需在tomcat\webapps\myapps\META-INF\context.xml的Context中增 加： 39. password="mypwd" driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver" maxIdle="2" maxWait="5000" validationQuery="select 1" username="sa" url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb" maxActive="4"/> 40.参数说明： 41.driveClassName：JDBC驱动类的完整的名称； 42.maxActive：同时能够从连接池中被分配的可用实例的最大数； 43.maxIdle：可以同时闲置在连接池中的连接的最大数； 44.maxWait：最大超时时间，以毫秒计； 45.password：用户密码； 46.url：到JDBC的URL连接； https://www.360docs.net/doc/e211374370.html,er：用户名称； 48.validationQuery：用来查询池中空闲的连接。 49.以上三种方式在tomcat 5.5.4下都可以。另外，sql server的jdbc driver 是从微软网站上下载的sql server jdbc (sp3)。 50. 51.tomcat5.0连接池配置 52.在tomcat 的下面路径（Tomcat \conf\Catalina\localhost）下建一个 xml文件，内容如下 53. type="javax.sql.DataSource"/> 54. 55. 56. 57. ory 58. 59. 63. 64. 65. 66. 67. 70. 71. 72. 73. 74. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 98. 99. 100. 101. 102. 107. 108. 109. 110. 111. 112. 113. 114. 115. 116. 119. 120. 121. 122. 123. 125. --> 126. 127. 128. 129. 130. 使用JA VA中的动态代理实现数据库连接池 作者通过使用JAVA中的动态代理实现数据库连接池，使使用者可以以普通的jdbc连接的使用习惯来使用连接池。 数据库连接池在编写应用服务是经常需要用到的模块，太过频繁的连接数据库对服务性能来讲是一个瓶颈，使用缓冲池技术可以来消除这个瓶颈。我们可以在互联网上找到很多关于数据库连接池的源程序，但是都发现这样一个共同的问题：这些连接池的实现方法都不同程度地增加了与使用者之间的耦合度。很多的连接池都要求用户通过其规定的方法获取数据库的连接，这一点我们可以理解，毕竟目前所有的应用服务器取数据库连接的方式都是这种方式实现的。但是另外一个共同的问题是，它们同时不允许使用者显式的调用Connection.close()方法，而需要用其规定的一个方法来关闭连接。这种做法有两个缺点： 第一：改变了用户使用习惯，增加了用户的使用难度。 首先我们来看看一个正常的数据库操作过程： int executeSQL(String sql) throws SQLException { Connection conn = getConnection(); //通过某种方式获取数据库连接 PreparedStatement ps = null; int res = 0; try{ ps = conn.prepareStatement(sql); res = ps.executeUpdate(); }finally{ try{ ps.close(); }catch(Exception e){} try{ conn.close();// }catch(Exception e){} } return res; } 使用者在用完数据库连接后通常是直接调用连接的方法close来释放数据库资源，如果用我们前面提到的连接池的实现方法，那语句conn.close()将被某些特定的语句所替代。 第二：使连接池无法对之中的所有连接进行独占控制。由于连接池不允许用户直接调用连接的close方法，一旦使用者在使用的过程中由于习惯问题直接关闭了数据库连接，那么连接池将无法正常维护所有连接的状态，考虑连接池和应用由不同开发人员实现时这种问题更容易出现。 综合上面提到的两个问题，我们来讨论一下如何解决这两个要命的问题。 首先我们先设身处地的考虑一下用户是想怎么样来使用这个数据库连接池的。用户可以通过特定的方法来获取数据库的连接，同时这个连接的类型应该是标准的java.sql.Connection。用户在获取到这个数据库连接后可以对这个连接进行任意的操作，包括关闭连接等。 通过对用户使用的描述，怎样可以接管Connection.close方法就成了我们这篇文章的主题。为了接管数据库连接的close方法，我们应该有一种类似于钩子的机制。例如在Windows 编程中我们可以利用Hook API来实现对某个Windows API的接管。在JAVA中同样也有这样一个机制。JAVA提供了一个Proxy类和一个InvocationHandler，这两个类都在 SUN的API文档中关于Proxy的描述很多，这里就不罗列出来。通过文档对接口InvocationHandler的描述我们可以看到当调用一个Proxy实例的方法时会触发Invocationhanlder的invoke方法。从JAVA的文档中我们也同时了解到这种动态代理机制只能接管接口的方法，而对一般的类无效，考虑到java.sql.Connection本身也是一个接口由此就找到了解决如何接管close方法的出路。 首先，我们先定义一个数据库连接池参数的类，定义了数据库的JDBC驱动程序类名，连接的URL以及用户名口令等等一些信息，该类是用于初始化连接池的参数，具体定义如下：public class ConnectionParam implements Serializable { private String driver; //数据库驱动程序 private String url; //数据连接的URL private String user; //数据库用户名 private String password; //数据库密码 private int minConnection = 0; //初始化连接数 private int maxConnection = 50; //最大连接数 private long timeoutValue = 600000;//连接的最大空闲时间 private long waitTime = 30000; //取连接的时候如 果没有可用连接最大的等待时间 其次是连接池的工厂类ConnectionFactory，通过该类来将一个连接池对象与一个名称对应起来，使用者通过该名称就可以获取指定的连接池对象，具体代码如下： /** * 连接池类厂，该类常用来保存多个数据源名称合数据库连接池对应的哈希 * @author liusoft */ public class ConnectionFactory { //该哈希表用来保存数据源名和连接池对象的关系表 static Hashtable connectionPools = null; static{ connectionPools = new Hashtable(2,0.75F); } /** * 从连接池工厂中获取指定名称对应的连接池对象 * @param dataSource 连接池对象对应的名称 * @return DataSource 返回名称对应的连接池对象 * @throws NameNotFoundException 无法找到指定的连接池 */ public static DataSource lookup(String dataSource) throws NameNotFoundException { Object ds = null; ds = connectionPools.get(dataSource); if(ds == null || !(ds instanceof DataSource)) throw new NameNotFoundException(dataSource); return (DataSource)ds; } /** * 将指定的名字和数据库连接配置绑定在一起并初始化数据库连接池 * @param name 对应连接池的名称 * @param param 连接池的配置参数，具体请见类ConnectionParam * @return DataSource 如果绑定成功后返回连接池对象 * @throws NameAlreadyBoundException 一定名字name已经绑定则抛 出该异常 * @throws ClassNotFoundException 无法找到连接池的配置中的驱动程序类 * @throws IllegalAccessException 连接池配置中的驱动程序类有误 * @throws InstantiationException 无法实例化驱动程序类 * @throws SQLException 无法正常 连接指定的数据库 */ public static DataSource bind(String name, ConnectionParam param) throws NameAlreadyBoundException,ClassNotFoundException, IllegalAccessException,InstantiationException,SQLException { DataSourceImpl source = null; try{ lookup(name); throw new NameAlreadyBoundException(name); }catch(NameNotFoundException e){ source = new DataSourceImpl(param); source.initConnection(); connectionPools.put(name, source); } return source; } /** * 重新绑定数据库连接池 * @param name 对应连接池的名称 * @param param 连接池的配置参数，具体请见类ConnectionParam * @return DataSource 如果绑定成功后返回连接池对象 * @throws NameAlreadyBoundException 一定名字name已经绑定则抛出该异常 * @throws ClassNotFoundException 无法找到连接池的配置中的驱动程序类 * @throws IllegalAccessException 连接池配置中的驱动程序类有误 * @throws InstantiationException 无法实例化驱动程序类 * @throws SQLException 无法正常 连接指定的数据库 */ public static DataSource rebind(String name, ConnectionParam param) throws NameAlreadyBoundException,ClassNotFoundException, IllegalAccessException,InstantiationException,SQLException { try{ unbind(name); }catch(Exception e){} return bind(name, param); } /** * 删除一个数据库连接池对象 * @param name * @throws NameNotFoundException */ public static void unbind(String name) throws NameNotFoundException { DataSource dataSource = lookup(name); if(dataSource instanceof DataSourceImpl){ DataSourceImpl dsi = (DataSourceImpl)dataSource; try{ dsi.stop(); dsi.close(); }catch(Exception e){ }finally{ dsi = null; } } connectionPools.remove(name); } } ConnectionFactory主要提供了用户将将连接池绑定到一个具体的名称上以及取消绑定的操作。使用者只需要关心这两个类即可使用数据库连接池的功能。下面我们给出一段如何使用连接池的代码： //以上代码是用来登记一个连接池对象，该操作可以在程序初始化只做一次即可 //以下开始就是使用者真正需要写的代码 DataSource ds = ConnectionFactory.lookup(name); try{ for(int i=0;i<10;i++){ Connection conn = ds.getConnection(); try{ testSQL(conn, sql); }finally{ try{ conn.close(); }catch(Exception e){} } } }catch(Exception e){ e.printStackTrace(); }finally{ ConnectionFactory.unbind(name); System.out.println("unbind datasource ok."); System.exit(0); } 从使用者的示例代码就可以看出，我们已经解决了常规连接池产生的两个问题。但是我们最最关心的是如何解决接管close方法的办法。接管工作主要在ConnectionFactory中的两句代码： DataSourceImpl是一个实现了接口javax.sql.DataSource的类，该类维护着一个连接池的对象。由于该类是一个受保护的类，因此它暴露给使用者的方法只有接口DataSource中定义的方法，其他的所有方法对使用者来说都是不可视的。我们先来关心用户可访问的一个方法getConnection 用户无可用连接 if(getConnectionCount() >= connParam.getMaxConnection()) conn = getFreeConnection(connParam.getWaitTime()); else{//没有超过连接数，重新获取一个数据库的连接 connParam.setUser(user); connParam.setPassword(password); Connection conn2 = DriverManager.getConnection(connParam.getUrl(), user, password); //代理将要返回的连接对象 _Connection _conn = new _Connection(conn2,true); synchronized(conns){ conns.add(_conn); } conn = _conn.getConnection(); } } return conn; } /** * 从连接池中取一个空闲的连接 * @param nTimeout 如果该参数值为0则没有连接时只是返回一个 null * 否则的话等待nTimeout毫秒看是否还有空闲连接，如果没有抛出异常 * @return Connection * @throws SQLException */ protected synchronized Connection getFreeConnection(long nTimeout) throws SQLException { Connection conn = null; Iterator iter = conns.iterator(); while(iter.hasNext()){ _Connection _conn = (_Connection)iter.next(); if(!_conn.isInUse()){ conn = _conn.getConnection(); _conn.setInUse(true); break; } } DataSourceImpl类中实现getConnection方法的跟正常的数据库连接池的逻辑是一致的，首先判断是否有空闲的连接，如果没有的话判断连接数是否已经超过最大连接数等等的一些逻辑。但是有一点不同的是通过DriverManager得到的数据库连接并不是及时返回的，而是通过一个叫_Connection的类中介一下，然后调用_Connection.getConnection返回的。如果我们没有通过一个中介也就是JAVA中的Proxy来接管要返回的接口对象，那么我们就没有办法截住Connection.close方法。 终于到了核心所在，我们先来看看_Connection是如何实现的，然后再介绍是客户端调用Connection.close方法时走的是怎样一个流程，为什么并没有真正的关闭连接。 /** * 数据连接的自封装，屏蔽了close方法 * @author Liudong */ class _Connection implements InvocationHandler { private final static String CLOSE_METHOD_NAME = "close"; private Connection conn = null; //数据库的忙状态 private boolean inUse = false; //用户最后一次访问该连接方法的时间 private long lastAccessTime = System.currentTimeMillis(); _Connection(Connection conn, boolean inUse){ this.conn = conn; this.inUse = inUse; } /** * Returns the conn. * @return Connection */ public Connection getConnection() { //返回数据库连接conn的接管类，以便截住close方法 Connection conn2 = (Connection)Proxy.newProxyInstance( conn.getClass().getClassLoader(), conn.getClass().getInterfaces(),this); return conn2; } /** * 该方法真正的关闭了数据库的连接 * @throws SQLException */ void close() throws SQLException{ //由于类属性conn是没有被接管的连接，因此一旦调用close方法 后就直接关闭连接 conn.close(); } /** * Returns the inUse. * @return boolean */ public boolean isInUse() { return inUse; } /** * @see https://www.360docs.net/doc/e211374370.html,ng.reflect.InvocationHandler#invoke(https://www.360docs.net/doc/e211374370.html,ng.Object, https://www.360docs.net/doc/e211374370.html,ng.reflect.Method, https://www.360docs.net/doc/e211374370.html,ng.Object) */ public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { Object obj = null; //判断是否调用了close的方法，如果调用close方法则把连接置为 无用状态 if(CLOSE_METHOD_NAME.equals(m.getName())) setInUse(false); else obj = m.invoke(conn, args); //设置最后一次访问时间，以便及时清除超时的连接 lastAccessTime = System.currentTimeMillis(); return obj; } /** * Returns the lastAccessTime. * @return long */ public long getLastAccessTime() { return lastAccessTime; } /** * Sets the inUse. * @param inUse The inUse to set */ public void setInUse(boolean inUse) { this.inUse = inUse; } } 一旦使用者调用所得到连接的close方法，由于用户的连接对象是经过接管后的对象，因此JAVA虚拟机会首先调用_Connection.invoke方法，在该方法中首先判断是否为close方法，如果不是则将代码转给真正的没有被接管的连接对象conn。否则的话只是简单的将该连接的状态设置为可用。到此您可能就明白了整个接管的过程，但是同时也有一个疑问：这样的话是不是这些已建立的连接就始终没有办法真正关闭？答案是可以的。我们来看看ConnectionFactory.unbind方法，该方法首先找到名字对应的连接池对象，然后关闭该连接池中的所有连接并删除掉连接池。在DataSourceImpl类中定义了一个close方法用来关闭所有的连接，详细代码如下： /** * 关闭该连接池中的所有数据库连接 * @return int 返回被关闭连接的个数 * @throws SQLException */ public int close() throws SQLException { int cc = 0; SQLException excp = null; Iterator iter = conns.iterator(); while(iter.hasNext()){ try{ ((_Connection)iter.next()).close(); cc ++; }catch(Exception e){ if(e instanceof SQLException) excp = (SQLException)e; } } if(excp != null) 该方法一一调用连接池中每个对象的close方法，这个close方法对应的是_Connection中对close的实现，在_Connection定义中关闭数据库连接的时候是直接调用没有经过接管的对象的关闭方法，因此该close方法真正的释放了数据库资源。 以上文字只是描述了接口方法的接管，具体一个实用的连接池模块还需要对空闲连接的监控并及时释放连接，详细的代码请参照附件。 手动编写连接池 1.package com.connection; 2. 3.import java.io.IOException; 4.import java.io.InputStream; 5.import java.sql.Connection; 6.import java.sql.DriverManager; 7.import java.sql.SQLException; 8.import java.util.HashMap; 9. 10.import java.util.Map; 11.import java.util.Properties; 12. 13.import com.util.PropertiesHelper; 14. 15.import oracle.jdbc.driver.OracleConnection; 16. 17.public class ConnectionPool { 18. private static Map n, Boolean>(); 19. 20. public static DataBase db=null; 21. 22. private static Properties prop; 23. 24. private static int POOLSIZE = 5; 25. 26. 27. public static synchronized void init(String file){ 28. if (pool.size() == 0) { 29. try { 30. 31. prop = readProperties(file); 32. } catch (IOException e) { 33. e.printStackTrace(); 34. } 35. try { 36. Class.forName(prop.getProperty("driver")); 37. } catch (ClassNotFoundException e) { 38. throw new RuntimeException(e); 39. } 40. if (prop.getProperty("poolsize").length() > 0) 41. POOLSIZE = Integer.parseInt(prop.getProperty("poolsize") ); 42. 43. for (int i = 0; i < POOLSIZE; i++) { 44. pool.put(newConnection(), true); 45. } 46. } 47. } 48. 49. private static synchronized Connection newConnection() { 50. Connection conn=null; 51. try { 52. String url=prop.getProperty("url"); 53. conn = DriverManager.getConnection(url, prop); 54. conn.setTransactionIsolation(Integer.parseInt(prop.getProper ty("islation"))); 55. conn.setAutoCommit(false); 56. } catch (SQLException e) { 57. e.printStackTrace(); 58. } 59. return conn; 60. } 61. 62. 63. 64. public static void closeAll() { 65. for (Connection c : pool.keySet()) { 66. try { 67. c.close(); 68. } catch (SQLException e) { 69. e.printStackTrace(); 70. } 71. } 72. } 73. 74. public static Connection getConnection() { 75. synchronized (pool) { 76. for (Connection conn : pool.keySet()) { 77. if (pool.get(conn) == false) { 78. pool.put(conn, true); 79. return conn; 80. } 81. } 82. } 83. Connection c=newConnection(); 84. return c; 85. } 86. 87. public static void release(Connection conn) { 88. if (conn != null) { 89. synchronized (pool) { 90. if (!pool.keySet().contains(conn)) { 91. try { 92. conn.close(); 93. } catch (SQLException e) { 94. throw new RuntimeException(e); 95. } 96. } else 97. pool.put(conn, false); 98. } 99. } 100. } 101. 102. public static void closePool() { 103. for (Connection conn : pool.keySet()) { 104. try { 105. conn.close(); 106. pool.clear(); 107. } catch (SQLException e) { 108. e.printStackTrace(); 109. } 110. } 111. } 112. 113. private static Properties readProperties(String file) throws IOExce ption { 114. Properties result = new Properties(); 115. InputStream is = ConnectionPool.class.getClassLoader() 116. .getResourceAsStream(file); 117. result.load(is); 118. return result; 119. } 120.} 测试代码： Java代码 1.package com.test; 2. 3.import java.sql.Connection; 4.import java.sql.ResultSet; 5.import java.sql.SQLException; 6. 7.import com.connection.ConnectionPool; 8.import com.dao.BaseDAO; 9. 10.public class Test extends Thread{ 11. 12. private String sql; 13. 14. private Connection c; 15. public Test(Connection c,String sql){ 16. 17. this.c=c; 18. this.sql=sql; 19. } 20. 21. public static void main(String[] args) { 22. ConnectionPool.init("oracle.properties"); 23. 24. for(int i=0;i<100;i++){ 25. String sql="select sysdate from dual"; 26. new Test(ConnectionPool.getConnection(),sql).start( ); 27. } 28. 29. } 30. 31. public void run(){ 32. try { 33. System.out.println(c); 34. ResultSet rs=c.createStatement().executeQuery(sql); 35. while(rs.next()){ 36. System.out.println(rs.getString(1)); 37. } 38. 39. } catch (SQLException e) { 40. e.printStackTrace(); 41. }finally{ 42. ConnectionPool.release(c); 43. } 44. } 45.} 模拟100个线程完全没问题，但是数量一旦上去了就不行了连接池得不到连接了。 我的思路是当你请求一个资源，池会看看池中有没有资源，有的话把这个资源分发给请求，没有的话，生成新的资源同时把该资源放到池中。当请求归还的时候，池会判断池中是否满了，如果满了，那么释放该资源。其中关键的，就是生成新资源，判断是否释放资源。 我自己写是为了多学点知识一直用别人封装好的连接池没什么意思，个人写的很烂，欢迎有技术性的建议。 两个建议： 1、getConnection中，如果池内没有连接则新建一个，新建的又不归池管，那连接池还有什么意义？应该判断如果池内连接全部占用则判断池连接数是否达到最大，如果最大了则阻塞wait，直到有人释放了连接才notify；如果没到，则新建一个连接放在池内并返回 2、release用来释放连接非常不好，因为很多习惯conn.close()写，导致了连接池中连接收不回来，应该创建连接的时候用Proxy重写Connection的close方法，在其中将true改成false 常使用web服务器的朋友大都了解，一般的web server有两部分日志： 一是运行中的日志，它主要记录运行的一些信息，尤其是一些异常错误日志信息 二是访问日志信息，它记录的访问的时间，IP，访问的资料等相关信息。 现在我来和大家介绍一下利用tomcat产生的访问日志数据，我们能做哪些有效的分析数据？ 首先是配置tomcat访问日志数据，默认情况下访问日志没有打开，配置的方式如下：编辑${catalina}/conf/server.xml文件.注:${catalina}是tomcat的安装目录 把以下的注释()去掉即可。 其中directory是产生的目录tomcat安装${catalina}作为当前目录 pattern表示日志生产的格式，common是tomcat提供的一个标准设置格式。其具体的表达式为%h %l %u %t "%r" %s %b 但本人建议采用以下具体的配置，因为标准配置有一些重要的日志数据无法生。 %h %l %u %t "%r" %s %b %T 具体的日志产生样式说明如下(从官方文档中摘录)： * %a - Remote IP address * %A - Local IP address * %b - Bytes sent, excluding HTTP headers, or '-' if zero * %B - Bytes sent, excluding HTTP headers * %h - Remote host name (or IP address if resolveHosts is false) * %H - Request protocol * %l - Remote logical username from identd (always returns '-') * %m - Request method (GET, POST, etc.) * %p - Local port on which this request was received * %q - Query string (prepended with a '?' if it exists) * %r - First line of the request (method and request URI) * %s - HTTP status code of the response * %S - User session ID * %t - Date and time, in Common Log Format * %u - Remote user that was authenticated (if any), else '-' * %U - Requested URL path * %v - Local server name * %D - Time taken to process the request, in millis * %T - Time taken to process the request, in seconds There is also support to write information from the cookie, incoming header, the Session or something else in the ServletRequest. It is modeled after the apache syntax: * %{xxx}i for incoming headers 用apache和tomcat搭建集群,实现负载均衡 一、集群和负载均衡的概念 （一）集群的概念 集群（Cluster）是由两台或多台节点机（服务器）构成的一种松散耦合的计算节点集合，为用户提供网络服务或应用程序(包括数据库、Web服务和文件服务等)的单一客户视图，同时提供接近容错机的故障恢复能力。集群系统一般通过两台或多台节点服务器系统通过相应的硬件及软件互连，每个群集节点都是运行其自己进程的独立服务器。这些进程可以彼此通信，对网络客户机来说就像是形成了一个单一系统，协同起来向用户提供应用程序、系统资源和数据。除了作为单一系统提供服务，集群系统还具有恢复服务器级故障的能力。集群系统还可通过在集群中继续增加服务器的方式，从内部增加服务器的处理能力，并通过系统级的冗余提供固有的可靠性和可用性。 （二）集群的分类 1、高性能计算科学集群： 以解决复杂的科学计算问题为目的的IA集群系统。是并行计算的基础，它可以不使用专门的由十至上万个独立处理器组成的并行超级计算机，而是采用通过高速连接来链接的一组1/2/4 CPU的IA服务器，并且在公共消息传递层上进行通信以运行并行应用程序。这样的计算集群，其处理能力与真正超级并行机相等，并且具有优良的性价比。 2、负载均衡集群： 负载均衡集群为企业需求提供更实用的系统。该系统使各节点的负载流量可以在服务器集群中尽可能平均合理地分摊处理。该负载需要均衡计算的应用程序处理端口负载或网络流量负载。这样的系统非常适合于运行同一组应用程序的大量用户。每个节点都可以处理一部分负载，并且可以在节点之间动态分配负载，以实现平衡。对于网络流量也如此。通常，网络服务器应用程序接受了大量入网流量，无法迅速处理，这就需要将流量发送给在其它节点。负载均衡算法还可以根据每个节点不同的可用资源或网络的特殊环境来进行优化。 3、高可用性集群： 为保证集群整体服务的高可用，考虑计算硬件和软件的容错性。如果高可用性群集中的某个节点发生了故障，那么将由另外的节点代替它。整个系统环境对于用户是一致的。 实际应用的集群系统中，这三种基本类型经常会发生混合与交杂。 （三）典型集群 科学计算集群： 1、Beowulf 当谈到Linux 集群时，许多人的第一反映是Beowulf。那是最著名的Linux科学软件集群系统。实际上，它是一组适用于在Linux 内核上运行的公共软件包的通称。其中包括流行的软件消息传递API，如“消息传送接口”(MPI) 或“并行虚拟机”(PVM)，对Linux 内核的修改，以允许结合几个以太网接口、高性能网络驱动器，对虚拟内存管理器的更改，以及分布式进程间通信(DIPC) 服务。公共全局进程标识空间允许使用DIPC 机制从任何节点访问任何进程。 2、MOSIX Beowulf类似于给系统安装的一个支持集群的外挂软件，提供了应用级的集群能力。而MOSIX 是彻底修改Linux的内核，从系统级提供了集群能力，它对应用而言是完全透明的，原有的应用程序，可以不经改动，就能正常运行在MOSIX系统之上。集群中的任何节点都可以自由地加入和移除，来接替其它节点的工作，或是扩充系统。MOSIX 使用自适应进程负载均衡和内存引导算法使整体性能最大化。应用程序进程可以在节点之间实现迁移，以利用最好 Tomcat集群与负载均衡（转载） 在单一的服务器上执行WEB应用程序有一些重大的问题，当网站成功建成并开始接受大量请求时，单一服务器终究无法满足需要处理的负荷量，所以就有点显得有点力不从心了。另外一个常见的问题是会产生单点故障，如果该服务器坏掉，那么网站就立刻无法运作了。不论是因为要有较佳的扩充性还是容错能力，我们都会想在一台以上的服务器计算机上执行WEB应用程序。所以，这时候我们就需要用到集群这一门技术了。 在进入集群系统架构探讨之前，先定义一些专门术语： 1. 集群(Cluster)：是一组独立的计算机系统构成一个松耦合的多处理器系统，它们之间通过网络实现进程间的通信。应用程序可以通过网络共享内存进行消息传送，实现分布式计算机。 2. 负载均衡(Load Balance)：先得从集群讲起，集群就是一组连在一起的计算机，从外部看它是一个系统，各节点可以是不同的操作系统或不同硬件构成的计算机。如一个提供Web服务的集群，对外界来看是一个大Web服务器。不过集群的节点也可以单独提供服务。 3. 特点：在现有网络结构之上，负载均衡提供了一种廉价有效的方法扩展服务器带宽和增加吞吐量，加强网络数据处理能力，提高网络的灵活性和可用性。集群系统(Cluster)主要解决下面几个问题： 高可靠性（HA）：利用集群管理软件，当主服务器故障时，备份服务器能够自动接管主服务器的工作，并及时切换过去，以实现对用户的不间断服务。 高性能计算（HP）：即充分利用集群中的每一台计算机的资源，实现复杂运算的并行处理，通常用于科学计算领域，比如基因分析，化学分析等。 负载平衡：即把负载压力根据某种算法合理分配到集群中的每一台计算机上，以减轻主服务器的压力，降低对主服务器的硬件和软件要求。 目前比较常用的负载均衡技术主要有： 1. 基于DNS的负载均衡 通过DNS服务中的随机名字解析来实现负载均衡，在DNS服务器中，可以为多个不同的地址配置同一个名字，而最终查询这个名字的客户机将在解析这个名字时得到其中一个地址。因此，对于同一个名字，不同的客户机会得到不同的地址，他们也就访问不同地址上的Web服务器，从而达到负载均衡的目的。 2. 反向代理负载均衡（如Apache+JK2+Tomcat这种组合） 使用代理服务器可以将请求转发给内部的Web服务器，让代理服务器将请求均匀地转发给多台内部Web服务器之一上，从而达到负载均衡的目的。这种代理方式与普通的代理方式有所不同，标准代理方式是客户使用代理访问多个外部Web服务器，而这种代理方式是多个客户使用它访问内部Web服务器，因此也被称为反向代理模式。 3. 基于NAT（Network Address Translation）的负载均衡技术（如Linux Virtual Server，简称LVS） Java的安装配置 1.在/etc/profile文件中配置相应的信息（如下） export JAVA_HOME=/usr/java/jdk1.6.0_20 export JRE_HOME=/usr/java/jdk1.6.0_20/jre export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH export PATH=$JAVA_HOME/bin:$PATH 2.是配置文件生效命令：Source/etc/profile 3.输入javac–version查看配置是否成功 TOMCAT安装配置 1.修改tomcat/bin文件夹下的catalina.sh文件，增加如下的内容： export JAVA_HOME=/usr/java/jdk1.5.0_08 export CLASSPATH=.:$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib export PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre/bin export CATALINA_HOME=/usr/local/tomcat （红色可选部分） usr/local/tomcat/bin/catalina.sh start 在/etc/rc.d/rc.local中加入: /usr/local/tomcat/bin/startup.sh（实现自动启动） 2.修改tomcat/conf文件夹下的tomcat-users.xml文件，添加相应的用户角色（manager）及用户信息（用户名及密码），具体的添加详见文件中的模板： 多台服务器tomcat集群 集群背景介绍 1.1 术语定义 服务软体是b/s或c/s结构的s部分，是为b或c提供服务的服务性软件系统。服务硬体指提供计算服务的硬件、比如pc机、pc服务器。服务实体通指服务软体和服务硬体。客户端指接受服务实体服务的软件或硬件。 1.2 两大关键特性 集群是一组协同工作的服务实体，用以提供比单一服务实体更具扩展性与可用性的服务平台。在客户端看来，一个集群就象是一个服务实体，但事实上集群由一组服务实体组成。与单一服务实体相比较，集群提供了以下两个关键特性： 可扩展性－－集群的性能不限于单一的服务实体，新的服务实体可以动态地加入到集群，从而增强集群的性能。 高可用性－－集群通过服务实体冗余使客户端免于轻易遇到out of service的警告。在集群中，同样的服务可以由多个服务实体提供。如果一个服务实体失败了，另一个服务实体会接管失败的服务实体。集群提供的从一个出错的服务实体恢复到另一个服务实体的功能增 强了应用的可用性。 1.3 两大能力 为了具有可扩展性和高可用性特点，集群的必须具备以下两大能力：负载均衡－－负载均衡能把任务比较均衡地分布到集群环境下的计算和网络资源。 错误恢复－－由于某种原因，执行某个任务的资源出现故障，另一服务实体中执行同一任务的资源接着完成任务。这种由于一个实体中的资源不能工作，另一个实体中的资源透明的继续完成任务的过程叫错误恢复。 负载均衡和错误恢复都要求各服务实体中有执行同一任务的资源存在，而且对于同一任务的各个资源来说，执行任务所需的信息视图（信息上下文）必须是一样的。 1.4 两大技术 实现集群务必要有以下两大技术： 集群地址－－集群由多个服务实体组成，集群客户端通过访问集群的集群地址获取集群内部各服务实体的功能。具有单一集群地址（也叫单一影像）是集群的一个基本特征。维护集群地址的设置被称为负载均衡器。负载均衡器内部负责管理各个服务实体的加入和退出，外部负责集群地址向内部服务实体地址的转换。有的负载均衡器实现真正的负载均衡算法，有的只支持任务的转换。只实现任务转换的负载均 Tomcat（免安装版）的安装与配置 一、下载Tomcat Tomcat可以从https://www.360docs.net/doc/e211374370.html,/网站下载，选择任意版本，在 Binary Distributions 下的zip包既是。 二、配置Tomcat 1、将下载Tomcat Zip压缩包解压。 2、修改\bin\startup.bat文件： 在第一行前面加入如下两行： SET JAVA_HOME=JDK目录 SET CATALINA_HOME=前面解压后Tomcat的目录或者%cd% 如果需要使用shutdown.bat关闭服务器的话，也按照上面加入两行。 3、这样，运行startup.bat就可以运行服务器，运行shutdown.bat就可以关闭服务器了。 4、修改\conf\tomcat-users.xml文件： 在 FineReport关于tomcat集群部署的方案 多台服务器集群后，配置权限、数据连接、模板、定时调度等，只能每台服务器一个个配置，不会自动同步到所有服务器。 针对上述情况，在FineReport中提供新集群部署插件，将xml配置文件、finedb/logdb 数据（定时任务、报表目录管理、批量导入、统计信息）的修改都对主机生效。其他辅机的信息读取也都从主机读取，保证了数据同步。 实现了灾备，即主机当即后，次主机会上位接替主机的工作，保证系统正常运作。 同时还增加了集群灾备之文件同步，会将主机的finedb、xml、模板、jar包、插件等等备份到其他节点的应用上。支持可以手动同步和自动同步。 插件介绍 设计器插件、服务器插件安装好之后，新集群部署，有主机、次主机、辅机之分，配置文件都从主机读取，辅机只能用作计算引擎分担压力，有点事当改配置文件的时候，不需要每个节点都去修改，直接改主机即可。 分布式集群 分布式集群文件系统：每台计算机各自提供自己的存储空间，并各自协调管理所有计算机节点中的文件。 这里测试修改主机的报表管理目录树平台标题，然后可以看到辅机会同步修改的配置。其中报表管理目录树存在finedb中，平台样式的平台标题存在fsconfig.xml中。 ?环境准备设置tomcat1、tomcat2、tomcat3集群，tomcat1为主机，tomcat2为辅机，tomcat3为次主机，tomcat集群。 WebReport工程分别放在tomcat下的webapps文件夹里 配置文件集群配置完成之后，修改将配置包resource文件夹下的cluster.xml打 开，如果没有这个文件的话，就新建一个，基本内容如下： 本文介绍如何配置Tomcat和Terracotta服务器将普通的Web应用部署到集群中，实现跨Tomcat节点的session复制，以达到负载均衡、提高系统吞吐量和灾难恢复的效果。 基本原理简介 一般利用Tomcat搭建Web应用集群有如下几种方法： 1、利用负载均衡器的粘session的方式把所有同一session的请求都发送到相同的Tomcat节点。这样不同用户的请求就被平均分配到集群中各个tomcat节点上，实现负载均衡的能力。这样做的缺点是没有灾难恢复的能力。一旦一个节点发生故障，这个节点上所有的session信息全部丢失； 2、利用Tomcat session复制的机制使得所有session在所有Tomcat节点中保持一致。当一个节点修改一个session数据的时候，该节点会把这个session的所有内容序列化，然后广播给所有其它节点。这样当下一个用户请求被负载均衡器分配到另外一个节点的时候，那个节点上有完备的session信息可以用来服务该请求。这种做法的问题是对session哪怕有一点点修改，也要把整个sessions数据全部序列化（serialize），还要广播给集群中所有节点，不管该节点到底需不需要这个session。这样很容易会造成大量的网络通信，导致网络阻塞。一般采用这种方式，当Tomcat节点超过4个时候，整个集群的吞吐量就不能再上升了； 3、第三种方式是通过cookie保存用户信息的一个或几个关键字，每一个http请求到达web应用的时候，web程序拿这个关键字到数据库中读取相关的数据，然后对其进行处理。也就是说把session数据保存到了数据库中。这样以来在内存中的session就完全不需要了。这样做的缺点就是加大了数据库的负载，使得数据库变成了集群的瓶颈。而通过构造数据库集群提高负载能力往往需要高额的成本。 Terracotta的基本原理是对于集群间共享的数据，当在一个节点发生变化的时候，Terracotta只把变化的部分发送给Terracotta服务器，然后由服务器把它转发给真正需要这个数据的节点。这样对网络的压力就非常小，各个节点也不必浪费CPU时间和内存进行大量的序列化操作。把这种集群间数据共享的机制应用在session同步上，相当于对tomcat第二种集群实现机制进行了优化，既避免了对数据库的依赖，又能达到负载均衡和灾难恢复的效果。在对比测试中，采用Terracotta搭建Tomcat集群，节点达到8个时候，整个集群的吞吐量还一直是线性增长的。 为了方便使用Terracotta搭建Tomcat集群，Terracotta提供了专门的插件tim-tomcat。下面将对集群的搭建进行详细描述。 准备工作 首先需要下载如下软件： Apache Tomcat 目前Terracotta官方支持的Tomcat版本为： Apache Tomcat Apache Tomcat Apache Tomcat Terracotta 或更高版本 安装过程 在所有机器上安装Java 请参考目前支持的软硬件平台 在所有机器上安装Terracotta 选一台机器作为Terracotta服务器 轻松实现Apache,Tomcat集群和负载均衡 作者:罗代均 ldj_work#https://www.360docs.net/doc/e211374370.html,,转载请保持完整性 0，环境说明 Apache :apache_2.0.55 1 个 Tomcat: apache-tomcat-5.5.17 (zip版) 2个 mod_jk:: mod_jk-apache-2.0.55.so 1个 第一部分：负载均衡 负载均衡，就是apache将客户请求均衡的分给tomcat1,tomcat2....去处理 1.安装apche,tomcat https://www.360docs.net/doc/e211374370.html,/下载Apache 2.0.55 https://www.360docs.net/doc/e211374370.html,/download-55.cgi下载tomcat5.5 zip版本（解压即可，绿色版） https://www.360docs.net/doc/e211374370.html,/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.15/下载mod_jk,注意和 apache版本匹配 按照jdk,我的路径为:E:\ide\apache\Apache2 解压两份Tomcat, 路径分别为 E:\ide\tomcat1,E:\ide\tomcat2 下载mod_jk 2.修改Apache配置文件http.conf 在apache安装目录下conf目录中找到http.conf 在文件最后加上下面一句话就可以了 include "E:\ide\apache\Apache2\conf\mod_jk.conf" 2. http.conf 同目录下新建mod_jk.conf文件，内容如下 #加载mod_jk Module LoadModule jk_module modules/mod_jk-apache-2.0.55.so #指定 workers.properties文件路径 JkWorkersFile conf/workers.properties #指定那些请求交给tomcat处理,"controller"为在workers.propertise里指定的负载分配控制器JkMount /*.jsp controller 3.在http.conf同目录下新建 workers.properties文件，内容如下 worker.list = controller,tomcat1,tomcat2 #server 列表 #========tomcat1======== worker.tomcat1.port=8009 #ajp13 端口号，在tomcat下server.xml配置,默认8009 worker.tomcat1.host=localhost #tomcat的主机地址，如不为本机，请填写ip地址 worker.tomcat1.type=ajp13 worker.tomcat1.lbfactor = 1 #server的加权比重，值越高，分得的请求越多 #========tomcat2======== worker.tomcat2.port=9009 #ajp13 端口号，在tomcat下server.xml配置,默认8009 worker.tomcat2.host=localhost #tomcat的主机地址，如不为本机，请填写ip地址 worker.tomcat2.type=ajp13 worker.tomcat2.lbfactor = 1 #server的加权比重，值越高，分得的请求越多 配置文件一般都在conf文件夹里，主要有server.xml，context.xml，tomcat_user.xml，web.xml四个常用配置文件，server主要是服务器设置的，例如端口设置，路径设置。context 里设置tomcat数据源，用来连接数据库。tomcat_user主要是用户名和密码的设置。web 是默认首页等等之类的设置。 元素名属性解释 server port 指定一个端口，这个端口负责监听关闭 tomcat 的请求 shutdown指定向端口发送的命令字符串 service name指定service 的名字 Connector(表示客户端和service之间的连接)port 指定服务器端要创建的端口号，并在这个断口 监听来自客户端的请求 minProcessors服务器启动时创建的处理请求的线程数maxProcessors最大可以创建的处理请求的线程数 enableLookups 如果为true ，则可以通过调用 request.getRemoteHost() 进行DNS 查询来 得到远程客户端的实际主机名，若为false 则 不进行DNS 查询，而是返回其ip 地址redirectPort 指定服务器正在处理http 请求时收到了一个 SSL 传输请求后重定向的端口号acceptCount 指定当所有可以使用的处理请求的线程数都被 使用时，可以放到处理队列中的请求数，超过 这个数的请求将不予处理 connectionTimeo ut 指定超时的时间数( 以毫秒为单位) Engine(表示指定service 中 的请求处理机，接收和处理来自Connector的请求)defaultHost 指定缺省的处理请求的主机名，它至少与其中 的一个host 元素的name 属性值是一样的 Context(表示一个 web 应用程序，通常为WAR 文件，关于WAR 的具体信息见servlet 规范)docBase应用程序的路径或者是WAR 文件存放的路径path 表示此web 应用程序的url 的前缀，这样请 求的url为http://localhost:8080/path/ **** reloadable 这个属性非常重要，如果为true ，则 tomcat 会自动检测应用程序的 /WEB-INF/lib 和/WEB-INF/classes 目录的 变化，自动装载新的应用程序，我们可以在不 重起tomcat 的情况下改变应用程序 host(表示name指定主机名 tomcat6.0配置 第一步：下载j2sdk和tomcat：到sun官方站点 最新的jdk为1.6.04，tomcat为6.0，建议jdk1.4以上，tomcat4.0以上 第二步：安装和配置你的j2sdk和tomcat：执行j2sdk和tomcat的安装程序，然后设置按照路径进 行安装即可。 1.安装j2sdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加 以下环境变量(假定你的j2sdk安装在c:\j2sdk1.4.2）： JAVA_HOME=c:\j2sdk1.4.2 classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表 当前路径) path=%JAVA_HOME%\bin 接着可以写一个简单的java程序来测试J2SDK是否已安装成功： 将上面的这段程序保存为文件名为Test.java的文件。 然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令 javac Test.java java Test 此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需 要仔细检查一下你的配置情况。 2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的 tomcat安装在c:\tomcat）： CATALINA_HOME：c:\tomcat CATALINA_BASE：c:\tomcat TOMCAT_HOME: C:\Tomcat 然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到 classpath中去，修改后的classpath如下： 修改位置如下图 具体的解释如下 Access Log Valve用来创建日志文件，格式与标准的web server日志文件相同。可以使用用日志分析工具对日志进行分析，跟踪页面点击次数、用户会话的活动等。Access Log Valve 的很多配置和行为特性与File Logger相同，包括每晚午夜自动切换日志文件。Access Log Valve可以和任何Catalina容器关联，记录该容器处理的所有请求。 例子如下： 一、Hello world 1、前期环境准备 1.准备两个解压版tomcat，如何同时启动两个tomcat，请看我的另一篇文章《一台机 器同时启动多个tomcat》。 2.nginx官网下载解压版nginx。 3.创建一个简单的web项目。为了直观的区分访问的哪个tomcat，在页面写上标记 8081、8082。 [MISSING IMAGE: , ] 4.分别部署到对应的tomcat下。如图： [MISSING IMAGE: , ] [MISSING IMAGE: , ] 2、配置nginx 进入nginx-1.10.1conf路径，修改配置文件nginx.conf。 1、配置服务器组，在http{}节点之间添加upstream配置。（注意不要写localhost，不然访问速度会很慢） upstream nginxDemo { server 127.0.0.1:8081; #服务器地址1 server 127.0.0.1:8082; #服务器地址2 2、修改nginx监听的端口号80，改为8080。 server { listen 8080; ...... } 3、在location{}中，利用proxy_pass配置反向代理地址；此处“http://”不能少，后面的地址要和第一步upstream定义的名称保持一致。 location / { root html; index index.html index.htm; proxy_pass http://nginxDemo; #配置方向代理地址 } 如下图： [MISSING IMAGE: , ] 3、启动nginx和tomcat，访问 我是Windows系统，所以直接在nginx-1.10.1目录下双击nginx.exe即可。 可在任务管理器中查看 Tomcat日志记录激活配置方法 【编写人】：孙福成 【日期】：2010年2月1日 目录 1.文档说明 (1) 2.系统日志激活方式 (1) 2.1.配置方式 (1) 2.2.语法说明 (1) 2.3.参数说明 (2) 2.4.日志样例 (2) 3.日志备份 (2) 4.日志统计................................................................................................. 错误！未定义书签。 1.文档说明 本文档描述Tomcat系统日志记录功能的激活和配置方式，适用于所有使用Tomcat4、5的Web应用。 2.系统日志激活方式 2.1.配置方式 编辑Tomcat/conf/server.xml文件,找到如下行: Apache+tomcat集群+session复制 作者：吴钢奇 时间：2010/09/23 MSN：w7374520@https://www.360docs.net/doc/e211374370.html, 目标：在服务器上搭建1个apache+4个tomcat应用，tomcat之间实现session复制。Tomcat解析所有的网页，apache此刻的作用就是做代理。参考了很多网上好文档，非常感谢前人无私奉献，谢谢！ 1、环境 硬件：一个四核3.0CPU，4G内存，200GSATA硬盘 系统：Redhat AS 5.3 源码包下载： 1、Httpd下载 https://www.360docs.net/doc/e211374370.html,/apache//httpd/httpd-2.2.16.tar.gz 2、Tomcat下载 https://www.360docs.net/doc/e211374370.html,//tomcat/tomcat-7/v7.0.2-beta/bin/apache-tomcat- 7.0.2.tar.gz 3、mod_jk 下载地址： https://www.360docs.net/doc/e211374370.html,/dist/tomcat/tomcat-connectors/jk/source/jk- 1.2.30/tomcat-connectors-1.2.30-src.tar.gz 2、安装apache [root@adman ~]# cd /usr/local/src/ #进入源码包下载目录，这个可以随便定[root@adman src]# tar zxvf httpd-2.2.16.tar.gz #解压缩 [root@adman src]# cd httpd-2.2.16 #进入解压目录 [root@adman httpd-2.2.16]# ./configure --prefix=/usr/local/apache2 \ > --enable-cache \ #configure参数根据自己的需要添加 > --enable-mem-cache \ — 可以使用help获得相关参数 > --with-mpm=prefork \ > --enable-so \ > --enable-rewrite \ > --enable-ssl [root@adman httpd-2.2.16]# make #编译 [root@adman httpd-2.2.16]# make install #安装 Linux下TOMCAT集群安装文档 1版本 Apache:httpd-2.2.21 Tomcat:apache-tomcat-6.0.18 2集群方式 使用Apache R-proxy方式 3 TOMCAT安装 上传apache-tomcat-6.0.18到服务器 Cd apache-tomcat-6.0.18 mkdir logs chmod 755 logs cd bin chmod 755 *.sh 启动：./startup.sh 关闭：./shutdown.sh 4 apache安装（源码安装方式） cd /usr/local/ mkdir apache2.2.21 上传httpd-2.2.21.tar.gz到服务器路径下 tar -zxvf httpd-2.2.21.tar.gz ./configure --prefix=/usr/local/apache2.2.21 --enable-mods-shared=most Make(编译) make install（安装） 5配置httpd.conf(假设需要更改监听的端口) 以下是列出两个需要修改的地方： ServerName 127.0.0.1:9008 Listen 9008 6启动 cd apache2.2.21/bin/ ./apachectl start 在浏览器中输入http://127.0.0.1/ 就可以看到 It works! 7安装mod_proxy.so和mod_proxy_ajp.so,mod_proxy_balancer .so模块 Cd /usr/local/apache2.2.21/httpd-2.2.21/modules/proxy /usr/local/apache2.2.21/bin/apxs -i -a -c mod_proxy.c proxy_util.c /usr/local/apache2.2.21/bin/apxs -i -a -c mod_proxy_ajp.c ajp*.c /usr/local/apache2.2.21/bin/apxs -i -a -c mod_proxy_balancer.c 安装成功后，可以到/usr/local/apache2.2.21/conf 查看文件httpd.conf 是否安装成功 LoadModule proxy_module modules/mod_proxy.so LoadModule proxy_ajp_module modules/mod_proxy_ajp.so LoadModule proxy_balancer_module modules/mod_proxy_balancer.so 8配置httpd.conf集群 #snail add 20111027 proxy配置信息 Tomcat6+Apache2.2集群配置说明文档 yysy2000@https://www.360docs.net/doc/e211374370.html, 2009-7-24 准备工作： 注：可点击链接直接下载相应的文件。 JDK 免述，这个要是搞不定，直接回家种地吧。本文使用1.6.0_13 Tomcat版本号：apache-tomcat-6.0.18.zip Apache版本号：apache_2.2.11-win32-x86-openssl-0.9.8i 另外：tomcat-connectors-1.2.28-src.zip（apache网站tomcat项目下有下载）mod_jk-1.2.28-httpd-2.2.3.so（2.2.3适合于apache2.2.x版本） 程序安装： 1.正常安装apache（默认安装到C:\Program Files\Apache Software Foundation\Apache 2.2 目录下） 2.解压缩apache-tomcat-6.0.18.zip到C:\Program Files\Apache Software Foundation\Tomcat6.0目录下，解压完毕后，重命名tomcat6.0_1, 3.复制tomcat6.0_1文件夹，重命名为tomcat6.0_2 4.拷贝mod_jk-1.2.28-httpd-2.2.3.so 到Apache2.2/modules目录下 5.解压tomcat-connectors-1.2.28-src.zip，拷贝tomcat-connectors-1.2.28-src\conf文件夹中的 workers.properties 到Apache2.2/conf 目录下(该文件中配置用于集群的Tomcat信息) tomcat配置： 注：以下配置使用端口号可自行定义，只要不和系统中已经使用的端口号冲突即可。 1.conf文件夹下的server.xml文件作如下修改： 1)更正SHUTDOWN端口（两个tomcat分别使用8005和8006） 型的企业应用每天都需要承受巨大的访问量，在着巨大访问量的背后有数台服务器支撑着，如果一台服务器崩溃了，那么其他服务器可以使企业应用继续运行，用户对服务器的运作是透明化的，如何实现这种透明化呢？由如下问题需要解决。 一．Session的复制 二．如何将请求发送到正常的服务器 针对以上问题，可以使用群集和负载均衡来解决，整体架构如下： (图片来自:https://www.360docs.net/doc/e211374370.html,) 中间由一台服务器做负载均衡（Load Balancer），它将所有请求，根据一定的负载均衡规则发送给指定的群集服务器（Cluster），群集服务器拥有着相同的状态和相同的应用程序，并且他们的Session是相互复制的，这样，不管访问哪台服务器都具有相同的结果，即使一台服务器崩溃掉以后，可以由其他集群服务器继续负责应用程序的运行。 Tomcat中如何配置群集我们假设有如下场景，一台负载均衡服务器负责请求的均衡，群集服务器A和群集服务器B组成一个群集，当某个群集服务器崩溃后，另外一台继续负责应用程序的运行。 一．配置Tomcat5.5.12群集服务器A 修改Tomcat配置文件server.xml 1．群集服务器A的端口号与B不冲突，即使Server Port,Connector,Coyote/JK2 AJP Connector的端口号唯一2．在Host元素下增加以下内容： 设计一个Tomcat访问日志分析工具
tomcat集群
Tomcat集群与负载均衡
linux下tomcat的配置及项目的部署流程
多台服务器tomcat集群
Tomcat(免安装版)的安装与配置
FineReport关于tomcat集群部署的方案
通过Terracotta实现基于Tomcat的Web应用集群
windows下Tomcat负载均衡和集群配置
tomcat配置文件server文件详解
tomcat配置信息
TOMCAT 开启访问日志功能(ACCESS LOG)
Nginx Tomcat 配置负载均衡集群
Tomcat系统日志激活配置方法
apache2.2.16+mod_jk.1.2.30+tomcat7.0.2集群session复制
linux下TOMCAT集群(proxy)安装文档
Tomcat6+Apache2.2集群配置说明文档
用apache和tomcat搭建集群,实现负载均衡