Apache Camel框架入门示例
分类：Camel2012-02-03 15:42 8527人阅读评论(6) 收藏举报apache框架exceptionexchangefilewebservice
Apache Camel是Apache基金会下的一个开源项目,它是一个基于规则路由和处理的引擎，提供企业集成模式的Java对象的实现，通过应用程序接口或称为陈述式的Java领域特定语言(DSL)来配置路由和处理的规则。其核心的思想就是从一个from源头得到数据,通过processor处理,再发到一个to目的的.
这个from和to可以是我们在项目集成中经常碰到的类型:一个FTP文件夹中的文件,一个MQ的queue,一个HTTP request/response,一个webservice等等.
Camel可以很容易集成到standalone的应用,在容器中运行的Web应用,以及和Spring一起集成.
下面用一个示例,介绍怎么开发一个最简单的Camel应用.
1,从https://www.doczj.com/doc/615934088.html,/download.html下载Jar包.在本文写作的时候最新版本是2.9. 本文用的是2.7,从2.7开始要求需要JRE1.6的环境.
下载的zip包含了Camel各种特性要用到的jar包.
在本文入门示例用到的Jar包只需
要:camel-core-2.7.5.jar,commons-management-1.0.jar,slf4j-api-1.6.1.jar.
2,新建一个Eclipse工程,将上面列出的jar包设定到工程的Classpath.
新建一个如下的类:运行后完成的工作是将d:/temp/inbox/下的所有文件移到d:/temp/outbox [java]view plaincopy
1.public class FileMoveWithCamel {
2.public static void main(String args[]) throws Exception {
3. CamelContext context = new DefaultCamelContext();
4. context.addRoutes(new RouteBuilder() {
5.public void configure() {
6.//from("file:d:/temp/inbox?noop=true").to("file:d:/temp/outbox
");
7. from("file:d:/temp/inbox/?delay=30000").to("file:d:/temp/outbo
x");
8. }
9. });
10. context.start();
11.boolean loop =true;
12.while(loop){
13. Thread.sleep(25000);
14. }
15. context.stop();
16. }
17.}
上面的例子体现了一个最简单的路由功能,比如d:/temp/inbox/是某一个系统FTP到Camel 所在的系统的一个接收目录.
d:/temp/outbox为Camel要发送的另一个系统的接收目录.
from/to可以是如下别的形式,读者是否可以看出Camel是可以用于系统集成中做路由,流程控制一个非常好的框架了呢?
from("file:d:/temp/inbox/?delay=30000").to("jms:queue:order");//delay=30000是每隔30秒轮询一次文件夹中是否有文件.
3,再给出一个从from到to有中间流程process处理的例子:
[java]view plaincopy
1.public class FileProcessWithCamel {
2.public static void main(String args[]) throws Exception {
3. CamelContext context = new DefaultCamelContext();
4. context.addRoutes(new RouteBuilder() {
5.
6.public void configure() {
7. FileConvertProcessor processor = new FileConvertProcessor();
8. from("file:d:/temp/inbox?noop=true").process(processor).to("fi
le:d:/temp/outbox");
9. }
10. });
11.
12. context.start();
13.boolean loop =true;
14.while(loop){
15. Thread.sleep(25000);
16. }
17. context.stop();
18. }
19.}
这里的处理只是简单的把接收到的文件多行转成一行
[java]view plaincopy
1.public class FileConvertProcessor implements Processor{
2.@Override
3.public void process(Exchange exchange) throws Exception {
4.try {
5. InputStream body = exchange.getIn().getBody(InputStream.cl
ass);
6. BufferedReader in = new BufferedReader(new InputStreamRead
er(body));
7. StringBuffer strbf = new StringBuffer("");
8. String str = null;
9. str = in.readLine();
10.while (str != null) {
11. System.out.println(str);
12. strbf.append(str + " ");
13. str = in.readLine();
14. }
15. exchange.getOut().setHeader(Exchange.FILE_NAME, "converted
.txt");
16.// set the output to the file
17. exchange.getOut().setBody(strbf.toString());
18. } catch (IOException e) {
19. e.printStackTrace();
20. }
21. }
22.}
在Eclipse里运行的时候,Camel默认不会把log信息打印到控制台,这样出错的话，异常是看不到的,需要把log4j配置到项目中.
[java]view plaincopy
1.log4j.appender.stdout = org.apache.log4j.ConsoleAppender
2.log4j.appender.stdout.Target = System.out
https://www.doczj.com/doc/615934088.html,yout = org.apache.log4j.PatternLayout
https://www.doczj.com/doc/615934088.html,yout.ConversionPattern = %-5p %d [%t] %c: %m%n
5.log4j.rootLogger = debug,s
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Apache Camel 框架集成Spring
Apache Camel提供了和Spring的集成,通过Spring容器(ApplicationContext)来管理Camel 的CamelContext,这样的话,就不需要写代码来控制CamelContext的初始化,启动和停止了.Camel会随着Spring的启动而启动起来.
本文将Apache Camel 框架入门示例(https://www.doczj.com/doc/615934088.html,/kkdelta/article/details/7231640)
中的例子集成到Spring 中,下面简单介绍一下集成的基本步骤.
1,新建一个Eclipse 工程,将Spring3的jar 包,和Camel 的jar 包配置到工程的classpath.
2,Route 类要继承RouteBuilde,如下
1 public class FileProcessWithCamelSpring extends RouteBuilder {
2 @Override
3 public void configure() throws Exception {
4 FileConvertProcessor processor = new FileConvertProcessor();
5 from("file:d:/temp/inbox?delay=30000").process(processor).to ("file:d:/temp/outbox");
6
}
7 }
3,Processor 仍然和和入门示例的代码相同. 01 public class FileConvertProcessor implements Processor{
02 @Override
03 public void process(Exchange exchange) throws Exception {
04 try {
05 InputStream body = exchange.getIn().getBody(InputStream.class);
06 BufferedReader in = new BufferedReader(new InputStreamReader(body));
07 StringBuffer strbf = new StringBuffer("");
08 String str = null;
09 str = in.readLine();
10 while (str != null) {
11 System.out.println(str);
12 strbf.append(str + " ");
13 str = in.readLine();
14 }
15 exchange.getOut().setHeader(Exchange.FILE_NAME, "conve
rted.txt");
16 // set the output to the file
17 exchange.getOut().setBody(strbf.toString());
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22
23 }
4,创建一个Spring的配置文件如下:注意要将camel的xmlns加入文件中
01
02 03 xmlns:xsi="https://www.doczj.com/doc/615934088.html,/2001/XMLSchema-instance" 04 xmlns:camel="https://www.doczj.com/doc/615934088.html,/schema/spring" 0 5 xsi:schemaLocation="https://www.doczj.com/doc/615934088.html,/schema/bean s https://www.doczj.com/doc/615934088.html,/schema/beans/spring-beans-3.0.xsd 0 6 https://www.doczj.com/doc/615934088.html,/schema/spring https://www.doczj.com/doc/615934088.html,/schema/spring/camel-spring.xsd" 07 default-autowire="byName" default-init-method="init"> 0 8 09 10 11
5,启动Spring容器,Camel会自动启动,不用像入门示例那样CamelContext context = new DefaultCamelContext(), context.addRoutes(..); context.start();
ApplicationContext ac = new
ClassPathXmlApplicationContext("config/cameltest.xml");
while (true) {
Thread.sleep(2000);
}
可见,Camel可以很容易的和Spring集成.
Camel还提供了"Spring DSL"来在XML中配置Route规则,不需要用JAVA类(如上面的FileProcessWithCamelSpring )来实现route.
查看源码
打印?
01
02 03 xmlns:xsi="https://www.doczj.com/doc/615934088.html,/2001/XMLSchema-instance" 04 xmlns:camel="https://www.doczj.com/doc/615934088.html,/schema/spring" 0 5 xsi:schemaLocation="https://www.doczj.com/doc/615934088.html,/schema/bean s https://www.doczj.com/doc/615934088.html,/schema/beans/spring-beans-3.0.xsd 0 6 https://www.doczj.com/doc/615934088.html,/schema/spring https://www.doczj.com/doc/615934088.html,/schema/spring/camel-spring.xsd" 07 default-autowire="byName" default-init-method="init"> 0 8 0 9 10 11 12 13 14 15 16 17
与第五步一样启动Spring容器,Camel会每隔30秒轮询一下看d:/temp/inbox是否有文件,有的话则进行处理.
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
Apache Camel框架之FTP路由
您的评价: 收藏该经验
在做项目集成类型的项目的时候,经常会有这样的需求,用户或者别的系统将文件传到一个FTP server,然后系统从FTP server取文件进行相应的处理.
本文简单的介绍和示例一个用Camel实现这样的需求:监听FTPserver是否有文件,取到文件做相应处理传到另外一个系统.
1,搭建一个FTP server,从https://www.doczj.com/doc/615934088.html,/projects/filezilla/files/ 下载FileZilla安装,设置一个用户yorker/123456.
可以参照这个网址https://www.doczj.com/doc/615934088.html,/filezilla-server.htm
2,在Camel里实现路由:
查看源码
打印?
01 CamelContext context = new DefaultCamelContext();
02 context.addRoutes(new RouteBuilder() {
03 public void configure() {
0 4 from("ftp://localhost/inbox?username=yorker&password=12345 6").to(
05 "file:d:/temp/outbox");
06 }
07 });
08 context.start();
09 boolean loop = true;
10 while (loop) {
11 Thread.sleep(25000);
12 }
13
14 context.stop();
这里主要是为了示例Camel对FTP的支持,没有加入processor的处理,downstream system 也仅仅是用放到本地文件夹做示例.不过真正做项目的时候,在to里可以是别的类型,如JMS 的queue,别的系统的FTB inbound文件夹,Web service等等.
如何在流程的中间加入processor 处理可以参见
https://www.doczj.com/doc/615934088.html,/kkdelta/article/details/7231640
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
Apache Camel 框架之JMS 路由
您的评价: 收藏该经验
继上次Camel 如何在做项目集成类型的项目中用于从FTP 取文件和传文件之后,我们在系
统集成中经常遇到的另一个应用就是将数据通过JMS 传到消息中间件的queue 里,或者从
消息中间件的queue 里取消息.
本文简单的介绍和示例一个用Camel 实现这样的需求:监听某一个文件夹是否有文件,取到
文件后发送到另外一个系统监听的queue.
1,因为要用JMS,这里介绍一个open source 的activeMQ,可以从
https://www.doczj.com/doc/615934088.html,/download.html 下载,下载后解压,bin 目录有一个activemq.bat
文件,在命令行里运行activemq 启动activeMQ,如果能从从浏览器里访问
http://localhost:8161/admin/则activeMQ 成功启动了.
2,在Camel 里实现上图所示的路由:JAVA 项目里需要将activeMQ 的jar 包配置到classpath
下,Java 代码如下:
01 private static String user = ActiveMQConnection.DEFAULT_USER;
02 private static String password = ActiveMQConnection.DEFAULT_PASSWORD;
03 private static String url = ActiveMQConnection.DEFAULT_BROKER_URL;
04
05 public static void main(String args[]) throws Exception {
06 CamelContext context = new DefaultCamelContext();
07 ConnectionFactory connectionFactory =
08 new ActiveMQConnectionFactory(user, password, url);
09 context.addComponent("jms",
10 JmsComponent.jmsComponentAutoAcknowledge(connectionFactory
));
11 System.out.println(url + " " + user + password);
12 context.addRoutes(new RouteBuilder() {
13 public void configure() {
14 from("file:d:/temp/inbox").to(
15 "jms:queue:TOOL.DEFAULT");
16 }
17 });
18 context.start();
19 boolean loop = true;
20 while (loop) {
21 Thread.sleep(25000);
22 }
23
24 context.stop();
25 }
Camel 会在路由的时候将文件的内容以binary message 发到activeMQ 的名为
'TOOL.DEFAULT'的queue .
用下面的代码可以从Camel 发送的queue 里取到消息.
查看源码
打印?
01 private static String user = ActiveMQConnection.DEFAULT_USER;
02 private static String password = ActiveMQConnection.DEFAULT_PASSWORD;
03 private static String url = ActiveMQConnection.DEFAULT_BROKER_URL;
04 private static boolean transacted;
05 private static int ackMode = Session.AUTO_ACKNOWLEDGE;
06
07 public static void main(String[] args) throws Exception {
08 ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(user, password, url);
09 Connection connection = connectionFactory.createConnection();
10 connection.start();
11 Session session = connection.createSession(transacted, ackMode);
12 Destination destination = session.createQueue("TOOL.DEFAULT");
13 MessageConsumer consumer = session.createConsumer(destination);
14 Message message = consumer.receive(1000);
15
16 System.out.println("Received: " + message);
17 BytesMessage bytesMsg = (BytesMessage) message;
18 byte[] bytes = new byte[(int) bytesMsg.getBodyLength()];
19 bytesMsg.readBytes(bytes);
20 System.out.println("contents: " + new String(bytes));
21 }
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Apache Camel 框架之HTTP 路由
您的评价: 收藏该经验
继介绍完Camel 如何处理FTP,JMS 接口之后,今天介绍一下系统集成的时候经常遇到的另
一个接口,HTTP,一个示例需求如下图所示:
本文给出一个简单的代码示例如何用Camel 来实现这样一个应用:
1,在一个JAVA 类里配置如下路由:这里只示例了HTTP 的部分,其他功能实现可以参见
Apache Camel 框架系列的其他博客.
01 public class HttpPollWithQuartzCamel {
02 public static void main(String args[]) throws Exception {
03 CamelContext context = new DefaultCamelContext();
04 context.addRoutes(new RouteBuilder() {
05 public void configure() {
06 from("quartz://report?cron=10 * * * * ?&stateful=true")
07 .to("http://localhost:8080/prjWeb/test.camelreq")
08 .to("file:d:/temp/outbox?fileName=http.csv");
09 );
10 }
11 });
12 context.start();
13 boolean loop = true;
14 while (loop) {
15 Thread.sleep(25000);
16 }
17 context.stop();
18 }
19 }
对上面代码的简单解释: from("quartz://report?cron=10 * * * * ?&stateful=true"),配置一个
quartz Job,每隔10秒发送一个HTTP request,将收到的内容保存为文件.
这里的http url 可以是任何可以访问的http url,如果在http 访问时候需要代理可以这么配
置:"https://www.doczj.com/doc/615934088.html,?proxyHost=https://www.doczj.com/doc/615934088.html,&proxyPort=8080"
这个例子需要用到quartz,和httpclient 等jar 包,可以从这里下载:
https://www.doczj.com/doc/615934088.html,/detail/kkdelta/4051072
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&7
针对 Java 开发者的 Apache Camel 入门指南
您的评价:收藏该经验
Apache Camel是一个非常实用的规则引擎库，能够用来处理来自于不同源的事件和信息。你可以在使用不同的协议比如VM，HTTP，FTP，JMS甚至是文件系统中来传递消息，并且让你的操作逻辑和传递逻辑保持分离，这能够让你更专注于消息的内容。
在这篇文章中，我将提供一个Java语言（非Groovy）的Apache Camel入门演示。
首先创建一个Maven项目的pom.xml。
01
02 03 xmlns:xsi="https://www.doczj.com/doc/615934088.html,/2001/XMLSchema-instance" 04 xsi:schemaLocation=" 05 https://www.doczj.com/doc/615934088.html,/POM/4.0.0 06 https://www.doczj.com/doc/615934088.html,/maven-v4_0_0.xsd"> 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
在这里我们只用到了camel-core.jar 包，实际上它提供了许多你可能用到的实用组件。出于
日志记录的目的，我使用了slf4j-simple 来作为日志记录的实现，从而我们可以从控制台上
看到输出。
接下来我们只需要构造一个路由类。路由就好比是Camel 中怎样将消息从一端传递到另一
端的一个指令定义。我们将会创建src/main/java/camelcoredemo/TimerRouteBuilder.java
文件，每隔一秒向处理器发送一个消息，简单打印出来。
01 package camelcoredemo;
02
03 import org.slf4j.*;
04 import org.apache.camel.*;
05 import org.apache.camel.builder.*;
06
07 public class TimerRouteBuilder extends RouteBuilder {
08 static Logger LOG =
LoggerFactory.getLogger(TimerRouteBuilder.class);
09 public void configure() {
10 from("timer://timer1?period=1000")
11 .process(new Processor() {
12 public void process(Exchange msg) {
13 https://www.doczj.com/doc/615934088.html,("Processing {}", msg);
14 }
15 });
16 }
17 }
以上就是这个示例的全部所需，现在编译运行。 bash> mvn compile
bash> mvn exec:java -Dexec.mainClass=org.apache.camel.main.Main -Dexec.args='-r
camelcoredemo.TimerRouteBuilder' 注意，这里我们并没有编写Java 类的main 入口，我们只是将RouteBuilder 的类名当作参
数简单传递给 org.apache.camel.main.Main,然后它将自动加载路由。
控制CamelContext
当启动Camel后，它会创建一个CamelContext对象，该对象拥有了很多关于如何运行Camel的信息，还包含我们所创建的Route的定义。现在如果你想通过CamelContext获得更多的控制，那么你需要编写自己的主类代码。我在这举个简单的例子。
01 package camelcoredemo;
02
03
04
05
06 import org.slf4j.*;
07 import org.apache.camel.*;
08 import org.apache.camel.impl.*;
09 import org.apache.camel.builder.*;
10
11
12
13
14 public class TimerMain {
15 static Logger LOG = LoggerFactory.getLogger(TimerMain.class);
16 public static void main(String[] args)throws Exception {
17 new TimerMain().run();
18 }
19 void run()throws Exception {
20 final CamelContext camelContext =new DefaultCamelContext();
21 camelContext.addRoutes(createRouteBuilder());
22 camelContext.setTracing(true);
23 camelContext.start();
24
25
26
27
28 Runtime.getRuntime().addShutdownHook(new Thread() {
29 public void run() {
30 try{
31 camelContext.stop();
32 }catch(Exception e) {
33 throw new RuntimeException(e);
34 }
35 }
36 });
37
38
39
40
41 waitForStop();
42 }
43 RouteBuilder createRouteBuilder() {
44 return new TimerRouteBuilder();
45 }
46 void waitForStop() {
47 while(true) {
48 try{
49 Thread.sleep(Long.MAX_VALUE);
50 }catch(InterruptedException e) {
51 break;
52 }
53 }
54 }
55 }
可以看到，我们在createRouteBuilder()方法中重用了已有的TimerRouteBuilder类。现在我们的主类对在什么时候创建、启动、停止CamelContext有了完全的控制。
context(camelContext)对象允许你全局性地控制如何配置Camel，而不是在Route级。它的JavaDoc链接给出了所有setter方法，你可以研究下它都可以做些什么。
注意到一点，我们也需要在我们的主类中提供少量设置代码。首先我们需要处理优雅关闭的问题，所以我们增加了一个Java关闭回调函数去调用context的stop()方法。其次在context 已经启动后，我们需要增加一个线程阻塞。如果在启动后你不阻塞你的主线程，那么它会在启动后就简单的退出了，那就没啥用了。你会把Camel一直作为一个服务(就像一个服务器)运行，直至你按下CTRL+C键去终止该进程。
改善启动CamelContext的主类
如果你不想像上面例子一样过多的处理主类设置代码，那么你可以简单地继承由
camel-core 提供的org.apache.camel.main.Main 类作为代替。通过利用这个类，你不仅可
以让你的context 自动设置，还可以获得所有附加的命令行特性，比如控制进程运行多久，
启用追踪，加载自定义route 类等等。
重构了下上一个例子，代码如下：
01 package camelcoredemo;
02
03 import org.slf4j.*;
04 import org.apache.camel.builder.*;
05 import org.apache.camel.main.Main;
06
07 public class TimerMain2 extends Main {
08 static Logger LOG = LoggerFactory.getLogger(TimerMain2.class);
09 public static void main(String[] args) throws Exception {
10 TimerMain2 main = new TimerMain2();
11 main.enableHangupSupport();
12 main.addRouteBuilder(createRouteBuilder());
13 main.run(args);
14 }
15 static RouteBuilder createRouteBuilder() {
16 return new TimerRouteBuilder();
17 }
18 }
现在TimerMain2类的代码比之前的更少了，你可以试试看，它应该和之前的功能一样。
1 bash> mvn compile
2 bash> mvn exec:java -Dexec.mainClass=camelcoredemo.TimerMain2
-Dexec.args='-t' 注意到我们给出-t 选项后，会转储Route 追踪。使用-h 会看到所有可用的选项。
用Camel 的注册机制添加bean
在之前的TimerRouteBuilder 例子中，我们已经在代码中创建了一个匿名Processor 。现在
如果你想将几个不同的Processor 放在一起，那么使用Camel 的注册机制添加bean 的方
式将能更好的减少代码混乱。Camel 允许你通过将processing 当作bean 注入到它的registry
space ，然后你只要把它们当作bean 组件来进行调用。如下是我的重构代码:
01 package camelcoredemo;
03 import org.slf4j.*;
04 import org.apache.camel.*;
05 import org.apache.camel.builder.*;
06 import org.apache.camel.main.Main;
07
08 public class TimerBeansMain extends Main {
09 static Logger LOG = LoggerFactory.getLogger(TimerBeansMain.class);
10 public static void main(String[] args)throws Exception {
11 TimerBeansMain main =new TimerBeansMain();
12 main.enableHangupSupport();
13 main.bind("processByBean1",new Bean1());
14 main.bind("processAgainByBean2",new Bean2());
15 main.addRouteBuilder(createRouteBuilder());
16 main.run(args);
17 }
18 static RouteBuilder createRouteBuilder() {
19 return new RouteBuilder() {
20 public void configure() {
21 from("timer://timer1?period=1000")
22 .to("bean:processByBean1")
23 .to("bean:processAgainByBean2");
24 }
25 };
26 }
27
28 // Processor beans
29 static class Bean1implements Processor {
30 public void process(Exchange msg) {
31 https://www.doczj.com/doc/615934088.html,("First process {}", msg);
32 }
33 }
34 static class Bean2implements Processor {
35 public void process(Exchange msg) {
36 https://www.doczj.com/doc/615934088.html,("Second process {}", msg);
37 }
39 }
现在Route类更简洁明了，同时处理代码也被重构到了独立的类中。当你需要编写很复杂的Route来实现业务逻辑时，这种方式能够帮助你更好的组织和测试你的代码。它能够让你构建像”乐高“积木那样可复用的POJO bean。Camel的registry space同样可用于其他很多用途，比如你可以自定义许多具有附加功能的endpoint组件或者注册一些信息，更或者替换线程池实现策略之内的事情。
上述Route示例是用所谓的Java DSL来构成的，它的可读性较高，你可以用IDE提供的支持查看所有可用于Route的方法。
我希望这篇文章能够帮助你跳过Camel的摸索阶段。除了已经提到的事件组件之外，camel 还提供了如下组件：
?bean component
?browse component
?dataset component
?direct component
?file component
?log component
?mock component
?properties component
?seda component
?test component
?timer component
?stub component
?validator component
?vm component
?xslt component
Have fun!
本文地址：https://www.doczj.com/doc/615934088.html,/translate/getting-started-with-apache-camel-using
原文地址：
http://saltnlight5.blogspot.ie/2013/08/getting-started-with-apache-camel-using.html
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
针对Java开发者的Apache Camel入门指南2013-09-04 15:43 论坛佚名
关键字：Java
Apache Camel是一个非常实用的规则引擎库，能够用来处理来自于不同源的事件和信息。你可以在使用不同的协议比如VM，HTTP，FTP，JMS甚至是文件系统中来传递消息，并且让你的操作逻辑和传递逻辑保持分离，这能够让你更专注于消息的内容。
在这篇文章中，我将提供一个Java语言(非Groovy)的Apache Camel入门演示。
首先创建一个Maven项目的pom.xml。
4.0.0 camel-spring-demo camel-spring-demo 1.0-SNAPSHOT jar UTF-8 2.11.1
org.apache.camel camel-core ${camel.version} org.slf4j slf4j-simple 1.7.5
在这里我们只用到了camel-core.jar包，实际上它提供了许多你可能用到的实用组件。出于日志记录的目的，我使用了slf4j-simple来作为日志记录的实现，从而我们可以从控制台上看到输出。
接下来我们只需要构造一个路由类。路由就好比是Camel中怎样将消息从一端传递到另一端的一个指令定义。我们将会创建src/main/java /camelcoredemo/TimerRouteBuilder.java 文件，每隔一秒向处理器发送一个消息，简单打印出来。
package camelcoredemo; import org.slf4j.*; import org.apache.camel.*; import
org.apache.camel.builder.*; public class TimerRouteBuilder extends RouteBuilder { static Logger LOG = LoggerFactory.getLogger(TimerRouteBuilder.class); public void configure()
{ from("timer://timer1?period=1000") .process(new Processor() { public void process(Exchange msg) { https://www.doczj.com/doc/615934088.html,("Processing {}", msg); } }); } }
以上就是这个示例的全部所需，现在编译运行。
bash> mvn compile bash> mvn exec:java -Dexec.mainClass=org.apache.camel.main.Main -Dexec.args='-r camelcoredemo.TimerRouteBuilder'
注意，这里我们并没有编写Java类的main入口，我们只是将RouteBuilder的类名当作参数简单传递给org.apache.camel.main.Main,然后它将自动加载路由。
控制CamelContext
当启动Camel后，它会创建一个CamelContext对象，该对象拥有了很多关于如何运行Camel的信息，还包含我们所创建的Route的定义。现在如果你想通过CamelContext获得更多的控制，那么你需要编写自己的主类代码。我在这举个简单的例子。
package camelcoredemo; import org.slf4j.*; import org.apache.camel.*; import
org.apache.camel.impl.*; import org.apache.camel.builder.*; public class TimerMain { static Logger LOG = LoggerFactory.getLogger(TimerMain.class); public static void main(String[] args) throws Exception { new TimerMain().run(); } void run() throws Exception { final CamelContext camelContext = new DefaultCamelContext(); camelContext.addRoutes(createRouteBuilder()); camelContext.setTracing(true); camelContext.start();
Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { try
{ camelContext.stop(); } catch (Exception e) { throw new RuntimeException(e); } } }); waitForStop(); } RouteBuilder createRouteBuilder() { return new TimerRouteBuilder(); } void waitForStop() { while (true) { try { Thread.sleep(Long.MAX_V ALUE); } catch (InterruptedException e) { break; } } } }
可以看到，我们在createRouteBuilder()方法中重用了已有的TimerRouteBuilder类。现在我们的主类对在什么时候创建、启动、停止CamelContext有了完全的控制。
context(camelContext)对象允许你全局性地控制如何配置Camel，而不是在Route级。它的JavaDoc链接给出了所有setter方法，你可以研究下它都可以做些什么。
注意到一点，我们也需要在我们的主类中提供少量设置代码。首先我们需要处理优雅关闭的问题，所以我们增加了一个Java关闭回调函数去调用context 的stop()方法。其次在
监视并记录Apache网站服务器的运行 LogFormat 指令承诺你告诉Apache你想要记录要求的哪些方面。而你仍需附加的指令来告诉Apache在哪里记录那些信息，这在下一章中将会介绍。下面的例子显示了两种最受欢迎的格式的配置：一般日志格式和整合日志格式。当Apache收到一个要求，他将会用相应的要求属性来替代以%为前缀的每一个域。假如您正在使用一般日志格式，您的日志文件里 尽管有附件提供日志格式的详尽索引，下表描述了一些最为重要的域： # %h: 客户端（例如，扫瞄器）向服务器发出连接要求时自己的当时的IP地址或域名(需开启HostNameLookups)。 # %u: 使用方式认证用户时，记录下的用户的编号。 # %t: 服务器同意到连接要求的时刻。 # %r: 客户端发出的原始连接要求中的文本信息，包含所使用的方法。 # %>s: 服务器应答扫瞄器后的返回状态代码，200表示要求成功。. # %b: 服务器应答扫瞄器发出的单个要求的回传对象的内容大小（字节为单位），不统计数据包头部字节。 整合日志格式在一般日志格式的基础上扩展出了两个附加的域。定义为： # %{Referer}i: 连接要求数据包包头，包含指向当前页面的文档关联信息。 # %{User-agent}i: 用户代理连接要求数据包包头，包含客户扫瞄器的信息。 创建一个自定义日志文件 您可能会想创建Apache自带以外的新的日志文件。下面的例子将运用CustomLog来创建一个新的日志文件，并储存由一个之前定义好的日志格式，即前一章提到的common，所定义的信息。您还能够用格式本身的定义来替换昵称。一个附加的，更为简单的指令是Transferlog，它只同意最后一个LogFormat指令提供的定义。
实训时间：2010年6月28日上午 搭建Apache服务器 实验目的 1.掌握配置用户个人站点的方法； 2.掌握配置目录访问控制与用户认证的方法； 3.掌握基于IP地址不同端口的虚拟主机的架设方法； 4.掌握基于不同IP地址的虚拟主机的架设方法； 实验内容 根据Apache服务器的默认设置，Web站点的相关文件保存在/var/www目录，而Web站点的日志文件保存于/var/log/httpd目录。安装安装Apache服务并进行相应的设置。 实验准备 两台计算机，一台安装RHEL Server5，另一台安装Windows XP。 一、建立Apache服务器的应用环境 1.安装Apache服务器软件包 （1）以超级用户登录到字符界面，输入“rpm -qa|grep httpd”命令，查看是否已安装Apache软件包，如没安装，则进行下一步。 （2）利用mount命令挂载安装光盘，依次输入如下命令： mount -t iso9660 /dev/cdrom /mnt rpm –ivh /mnt/Server/apr-1.2.7-11.i386.rpm rpm –ivh /mnt/Server/apr-util-1.2.7-6.i386.rpm rpm –ivh /mnt/Server/httpd-2.2.3-6.el5.i386.rpm 2.设置RHEL Server5计算机，其IP地址为192.168.0.10，子网掩码为255.255.255.0；允 许www服务通过防火墙，关闭SELinux，并启动Apache服务器。 （1）超级用户在字符界面输入“setup”命令，启动文字模式的系统设置程序。使用方向键将光标移至“Network configuration”（网络配置）选项，按回车，显示网卡信息。（2）选中网卡，再次按回车，出现网卡配置界面，按Tab键将光标移至“Use DHCP” 后的“*”，按[Space]键取消选择，然后在“Static IP”后输入IP地址“192.168.0.10”，在“Netmask”后输入掩码“255.255.255.0”。然后按Tab键将光标移至“OK”按钮按回车键，保存网卡设置。 （3）回到网卡设备选择界面，移动光标至“Quit”按回车。回到工具选择界面，选择“Firewall configration”（防火墙配置）选项按回车，出现防火墙配置界面，移动光标至“Disabled”，并按【Space】键选择此项。 （4）移动光标至“Customize”按钮按回车，出现防火墙自定义配置界面，选中“www” 选项。最后关闭此程序。 （5）为让系统设置起效，重启计算机。 3.测试Apache服务器。 在Windows计算机中启动IE浏览器，在地址栏中输入RHEL Server5主机的IP地址，将显示/var/www/html目录下index.html文件的内容。 二、配置个人Web站点。 1.配置Apach服务器，允许Linux用户架设其个人Web站点。 超级用户首先备份配置文件httpd.conf，输入命令“cp /etc/httpd/conf/httpd.conf /etc/httpd/conf/httpd.back”，以保证即使Apache服务器的配置错误也可以恢复初始设置。（1）输入“vi /etc/httpd/conf/httpd.conf”。 （2）在vi 命令模式下输入“/mod_userdir.c”按回车，查找文件中的“mod_userdir.c”字符
在Linux下配置Apache服务器 一、实验目的 完成本次实训，将能够: ●配置基本的Apache服务器 ●配置个人用户Web站点。 ●配置虚拟目录别名功能。 ●配置主机访问控制。 ●配置用户身份验证功能.。 ●配置基于IP地址的虚拟主机. 二、实验环境 1、RedHat Linux4AS. 2、Apache 2.0 三、实验内容 1.配置基本的Apache服务器 2.配置个人用户Web站点。 3.配置虚拟目录别名功能。 4.配置主机访问控制。 5.配置用户身份验证功能.。 6.配置基于IP地址的虚拟主机。 四、实验要求 在Linux操作系统下配置Apache服务器。 五、注意事项 1.在修配置文件下注意区分大小写、空格。 2.在每次重新开机后都必须启动Apachec服务器。 3.在每次修改完主配置文件后保存起来，必须重启Apachec服务器，如果不重启会 导致配置无效，最终导致实验失败。 六、实验步骤 1、检测是否安装了Apache软件包: A、首先为服务器网卡添加一个固定的IP地址。 B、在Web浏览器的地址栏中输入本机的IP地址，若出现Test Page测试页面（该 网页文件的默认路径为var/www/html/index.html）如下图1所示就说明Apache 已安装并已启动。
另一种方法是使用如下命令查看系统是否已经安装了Apache软件包： [root@rhe14~]# rpm –aq | grep httpd Httpd-suexec-2.0.52-9.ent Httpd-manual-2.0.52-9.ent System-config-httpd-1.3.1-1 Httpd-devel-2.0.52-9.ent 出现以上内容表明了系统已安装Apache软件包。 2、安装Apache软件包 超级用户（root）在图形界面下选择“应用程序”|“系统设置”|“添加/删除应用程序”命令，选择“万维网服务器”软件包组，在单击“更新”按钮就可以安装与Apache相关的软件包。 3、Apache的基本配置 （1）打开终端输入[root@rhe14~]# /etc/rc.d/init.d/httpd start //启动Apache 或者 [root@rhe14~]# apachectl start //启动Apache [root@rhe14~]# apachectl stop //停止Apache服务 [root@rhe14~]# apachectl restart //重启Apache服务 [root@rhe14~]# apachectl configtest //测试Apache服务器配置语法（2）在httpd.conf将Apache的基本配置参数修改、将一些注释的语句取消注释，或将某些不需要的参数注释掉。 （3）将包括index.html在内的相关网页文件复制到指定的Web站点根目下（var/www/html/index.html） （4）重启httpd进程 (5) 在Web浏览器下输入配置的ip地址出现如下图2，那表明基本配置成功了:
【实验8】Apache服务器的安装和配置 一、实验目的： 1.掌握Apache Web服务器的安装和配置。 2.使用虚拟主机在同一台服务器上架设多个网站。 二、【实验环境】 1.虚拟机软件VM Ware 6.0，Redhat Enterprise Linux虚拟机或光盘镜像文 件。 2.2台以上机器组成的局域网。 三、【实验原理】 （一）Apache服务简介 Apache是世界使用排名第一的Web服务器软件。它可以运行在几乎所有广泛使用的计算机平台上。 Apache源于NCSAhttpd服务器，经过多次修改，成为世界上最流行的Web 服务器软件之一。Apache取自“a patchy server”的读音，意思是充满补丁的服务器，因为它是自由软件，所以不断有人来为它开发新的功能、新的特性、修改原来的缺陷。Apache的特点是简单、速度快、性能稳定，并可做代理服务器来使用。 （二）虚拟主机 所谓虚拟主机，也叫“网站空间”就是把一台运行在互联网上的服务器划分成 多个“虚拟”的服务器，每一个虚拟主机都具有独立的域名和完整的Internet服务 器（支持WWW、FTP、E-mail等）功能。一台服务器上的不同虚拟主机是各自 独立的，并由用户自行管理。 虚拟主机技术是互联网服务器采用的节省服务器硬体成本的技术，虚拟主机 技术主要应用于HTTP服务，将一台服务器的某项或者全部服务内容逻辑划分 为多个服务单位，对外表现为多个服务器，从而充分利用服务器硬体资源。如果 划分是系统级别的，则称为虚拟服务器。
（三）Linux中虚拟主机的分类 1、基于IP地址的虚拟主机 如果某公司有多个独立的IP地址可用，那么可以用不同的IP地址来配置虚拟主机。 2、基于端口的虚拟主机 如果只有一个IP地址，但是要架设多个站点，可以使用端口来区分，每个端口对应一个站点。这样配置的话，用户在访问的时候必须在 URL中指明端口号才能访问相应的网站。 3、基于名称的虚拟主机 使用基于IP地址或者端口的虚拟主机，能够配置的站点数目有限，而使用基于名称的虚拟主机，可以配置任意数目的虚拟主机，而不需要 额外的IP地址，也不需要修改端口号。 四、实验步骤 本实验请勿使用【系统】→【管理】→【服务器设置】中的【HTTPD】工具来配置，否则后果自负！ （一）Apache服务器的启动 1、测试是否已安装Apache服务器： [root@localhost ~]#rpm –qa httpd 2、启动Apache服务器： [root@localhost ~]#service httpd start （二）基于端口的虚拟主机的配置 1、在/etc/httpd目录中，建立一个名为vhostconf.d的子目录，用来存放虚拟 主机的配置文件。 2、在/var/www目录中，建立一个名为websites的子目录，用于存放网站源 文件；在website目录下再建立ipvhost1和ipvhost2文件夹，用于区分各 个站点。
LinuxApacheWeb服务器配置教程 Linux阿帕奇网络服务器配置教程 阿帕奇的主要特点 根据著名的万维网服务器研究公司进行的一项调查，全世界50%以上的万维网服务器使用阿帕奇，排名世界第一。 阿帕奇的出生非常戏剧化。当NCSA万维网服务器项目停止时，那些使用NCSA万维网服务器的人开始用他们的补丁来交换服务器，他们很快意识到有必要建立一个论坛来管理这些补丁。就这样，阿帕奇集团诞生了，后来这个集团在NCSA的基础上建立了阿帕奇。 阿帕奇的主要特点是: 。可以在所有计算机平台上运行； 。支持最新的HTTP 1.1协议； 简单而强大的基于文件的配置； 。支持通用网关接口CGI 。支持虚拟主机； 。支持HTTP认证； 。集成的Perl脚本编程语言； 。集成代理服务器； 。拥有可定制的服务器日志；。支持服务器端包含命令。支持安全套接字层。用户会话过程的跟踪能力；支持FastCGI。支持Java小服务程序。 安装Apache流程
安装Apache 接下来，我们将开始征服阿帕奇的漫长旅程。我们将一步一步地学习使用Apache，从介绍到掌握，通过需求的一步一步的例子。 系统需求 运行Apache不需要太多的计算资源。它运行良好的Linux系统有6-10MB的硬盘空间和8 MB的内存。然而，单独运行Apache可能不是您想要做的。更有可能的是，您希望运行Apache来提供WWW服务，启动CGI流程，并充分利用WWW所能提供的所有惊人功能。在这种情况下，您需要提供额外的磁盘空间和内存空间来反映负载要求。换句话说，它不需要太多的系统资源来启动WWW服务，但是它需要更多的系统资源来为大量的客户提供服务。获取软件 你可以呆在 错误日志命令用于指定错误日志文件名和路径。 命令格式:错误日志[日志文件名] 示例:错误日志/var/ srm.conf Srm.conf是一个资源配置文件，它告诉服务器您想在WWW站点上提供什么资源，在哪里以及如何提供这些资源。 DocumentRoot命令指定主文档的地址。 命令格式:文档根[路径] 示例:文档根目录/主页/ UserDir命令，用于指定个人主页的位置。如果你有一个用户测试，
Apache服务器的安装与配置 一、安装Apache 双击可执行文件apache_1.3.33-win32-x86-no_src.exe，将Apache服务器软件安装至C:\Apache目录下。 二、设置C:\apache\conf\httpd.donf文件 修改Apache的核心配置文件c:\apache\conf\httpd.conf（说明一点：“#”为Apache的注释符号）。修改方法如下： 1、寻找到ServerName。这里定义你的域名。这样，当Apache Server运行时，你可以在浏览器中访问自己的站点。如果前面有#，记得删除它。 2、寻找到ServerAdmin。这里输入你的E-Mail地址。 （以上两条在安装时应该已经配置好了，所以不必改动，这里介绍一下，主要是为了日后的修改） 3、寻找到。向下有一句Options，去掉后面所有的参数，加一个All（注意区分大小写！A 大写，两个l小写。下同。）；接着还有一句Allow Override，也同样去掉后面所有的参数，加一个All。
三大WEB服务器对比分析（apache ,lighttpd,nginx）一．软件介绍(apache lighttpd nginx) 1. lighttpd Lighttpd是一个具有非常低的内存开销，cpu占用率低，效能好，以及丰富的模块等特点。lighttpd 是众多OpenSource轻量级的web server中较为优秀的一个。支持FastCGI, CGI, Auth, 输出压缩(output compress), URL重写, Alias等重要功能。 Lighttpd使用fastcgi方式运行php,它会使用很少的PHP进程响应很大的并发量。 Fastcgi的优点在于： ·从稳定性上看, fastcgi是以独立的进程池运行来cgi,单独一个进程死掉,系统可以很轻易的丢弃,然后重新分配新的进程来运行逻辑. ·从安全性上看, fastcgi和宿主的server完全独立, fastcgi怎么down也不会把server搞垮, ·从性能上看, fastcgi把动态逻辑的处理从server中分离出来, 大负荷的IO处理还是留给宿主server, 这样宿主server可以一心一意作IO,对于一个普通的动态网页来说, 逻辑处理可能只有一小部分, 大量的图片等静态IO处理完全不需要逻辑程序的参与(注1) ·从扩展性上讲, fastcgi是一个中立的技术标准, 完全可以支持任何语言写的处理程序(php,java,python...) 2.apache apache是世界排名第一的web服务器, 根据netcraft(https://www.doczj.com/doc/615934088.html,)所作的调查,世界上百分之五十以上的web服务器在使用apache. 1995年4月, 最早的apache(0.6.2版)由apache group公布发行. apache group 是一个完全通过internet进行运作的非盈利机构, 由它来决定apache web服务器的标准发行版中应该包含哪些内容. 准许任何人修改隐错, 提供新的特征和将它移植到新的平台上, 以及其它的工作. 当新的代码被提交给apache group时, 该团体审核它的具体内容, 进行测试, 如果认为满意, 该代码就会被集成到apache的主要发行版中. apache 的特性: 1) 几乎可以运行在所有的计算机平台上. 2) 支持最新的http/1.1协议 3) 简单而且强有力的基于文件的配置(httpd.conf). 4) 支持通用网关接口(cgi) 5) 支持虚拟主机.
1、如何设置请求等待时间 在httpd.conf里面设置： TimeOut n 其中n为整数，单位是秒。 设置这个TimeOut适用于三种情况： 2、如何接收一个get请求的总时间 接收一个post和put请求的TCP包之间的时间 TCP包传输中的响应（ack）时间间隔 3、如何使得apache监听在特定的端口 修改httpd.conf里面关于Listen的选项，例如： Listen 8000 是使apache监听在8000端口 而如果要同时指定监听端口和监听地址，可以使用： Listen 192.170.2.1:80 Listen 192.170.2.5:8000 这样就使得apache同时监听在192.170.2.1的80端口和192.170.2.5的8000端口。 当然也可以在httpd.conf里面设置： Port 80 这样来实现类似的效果。 4、如何设置apache的最大空闲进程数 修改httpd.conf，在里面设置： MaxSpareServers n 其中n是一个整数。这样当空闲进程超过n的时候，apache主进程会杀掉多余的空闲进程而保持空闲进程在n，节省了系统资源。如果在一个apache非常繁忙的站点调节这个参数才是必要的，但是在任何时候把这个参数调到很大都不是一个好主意。 同时也可以设置： MinSpareServers n 来限制最少空闲进程数目来加快反应速度。 5、apache如何设置启动时的子服务进程个数 在httpd.conf里面设置： StartServers 5 这样启动apache后就有5个空闲子进程等待接受请求。 也可以参考MinSpareServers和MaxSpareServers设置。 6、如何在apache中设置每个连接的最大请求数 在httpd.conf里面设置： MaxKeepAliveRequests 100 这样就能保证在一个连接中，如果同时请求数达到100就不再响应这个连接的新请求，保证了系统资源不会被某个连接大量占用。但是在实际配置中要求尽量把这个数值调高来获得较高的系统性能。 7、如何在apache中设置session的持续时间 在apache1.2以上的版本中，可以在httpd.conf里面设置： KeepAlive on KeepAliveTimeout 15 这样就能限制每个session的保持时间是15秒。session的使用可以使得很多请求都可以通过同一个tcp
A p a c h e服务器配置毕 业设计 目录 摘要 ................................................................................................................ 错误！未定义书签。 1 综述 (1) 1.1 架设WWW网站的意义 (1) 1.2 WWW的工作原理 (1) 1.3 在Linux下构建WWW服务器 (2) 1.3.1 关于硬件配置 (2) 1.3.2 将linux用作www服务器 (2) 2 Red Hat Linux的安装与使用 (4) 2.1 Red Hat Linux9.0简介 (4) 2.1.1 Red Hat Linux的网络功能 (6) 2.1.2 Red Hat Linux的文件类型 (9) 2.2 Red Hat Linux9.0的安装和配置 (11) 2.2.1 合理划分分区 (11) 2.2.2 了解相关信息 (12) 2.2.3 图形化安装过程 (13) 3 WWW服务器的建立 (27) 3.1 Apache的体系结构及性能 (27) 3.1.1 Apache的体系结构 (27) 3.1.2 Apache性能简介 (28) 3.2 配置并启动Apache (31) 3.2.1 配置文件httpd.conf (31) 3.2.2 Apache服务的安装、启动与停止 (32) 3.3 设置用户个人主页 (33) 3.3.1设置Linux系统用户个人主页的目录 (33) 3.3.2设置用户个人主页所在目录的访问权限 (33) 3.4 设置虚拟主机 (34) 3.4.1 配置DNS (34) 4 建立和完善WWW站点 (42) 4.1建立安全传输的WWW站点 (42) 4.1.1认识SSL安全协议 (42) 4.1.2 维护站点安全性应注意的问题 (42) 5 结论 (44) 致谢 ................................................................................................................ 错误！未定义书签。参考文献.. (45) 8
web服务器的发送和接受 可以通过httpwatch来了解 https://www.doczj.com/doc/615934088.html, cmd中的操作 1.apache其实就输一个软件，apache安装目录下的bin\httpd.exe 先进入到apache\bin目录 httpd -k start[shutdown][restart] 2.如果你希望在任何一个目录下都可以运行我们的httpd.exe则需要做一个环境变量的设置 重新进入控制台cmd 关于端口： apache默认在80端口监听 一台机器可以有：1-65535号端口（2个字节(256*256)） 查看系统正在监听的端口：netstat -an或netstat -nab（发现是哪个程序在监听） 一台机器的一个端口只能被一个程序监听，一个程序可以监听多个端口 端口分为有名端口1-1024，一般别去用 apache修改配置端口 配置文档位置：apache2.2/conf/http.conf 1.添加Listen 8080 2.重新启动apache apache的目录 /bin 该目录用于存放apache常用的命令，如httpd /cgi-bin 该目录用于存放linux/unix下常用的命令 /conf 该目录用于存放配置文件，如httpd.conf /error 该目录用于存放apache启动关闭的错误 /htdocs 该目录用于存放我们的默认站点的文件夹 /icons 该目录用于存放图标 /logs 该目录用于存放apache的相关日志，如error.log,install.log /manual 该目录用于存放apache的手册 /modules 该目录用于存放apache的模块.so的文件 apache是基于模块化设计的，核心代码并不多，大多数的功能都被分散到各个模块中运行机制： MPM:multi processing modules:多重处理模块 APR:Apache Portable Runtime:可移植运行库 生命周期： 启动，配置=》模块初始化=》子进程初始化=》请求循环=》子进程结束 启动阶段===============================》运行阶段============= Apache配置虚拟目录(默认是htdocs) 1.配置虚拟目录在apache的conf目录下的httpd.conf的
Apache 安装后启动然后配置即可.记得开启80 端口. iptables –I INPUT –p tcp –dport 80 –j ACCEPT 开启tcp 80 端口 apache 的配置文件: httpd.conf 路径: /etc/httpd/conf/httpd.conf DocumentRoot “/var/www/html”设置主目录的路径 DirectoryIndex index.html index.html.var 设置默认主文档,中间用空格格开 Listen 80 Listen 192.168.1.1:80 设置apache监听的IP地址和端口号,可添加多个 ServerRoot “/etc/httpd”设置相对根目录的路径(存放配置文件和日志文件) ErrorLog Logs/error_log 设置错误日志存放路径 CustomLog Logs/access_log combined (日志格式) 设置访问日志存放路径 如果日志文件存放路径不是以”/”开头,则意味着该路径相对于ServerRoot 的相对路径. ServerAdmin 邮箱地址{设置管理员的E-mail地址 ServerName FQDN名或IP地址{设置服务器主机名 由于Apache默认字符集为西欧(UTF-8),所以客户端访问中文网页时会出现乱码. 将语句“AddDefaultCharset UTF-8”改为“AddDefaultCharset GB2312”方可解决,不过要重新启动Apache服务. 修改完默认字符集后,客户端如需访问,要先清空浏览器的缓存.
创建虚拟目录,添加Alias语句即可 Alias /ftp “/var/ftp”Alias 虚拟目录名物理路径
Apache服务器安全问题 Apache服务器面临的安全问题 (2) HTTP拒绝服务 (2) 缓冲区溢出 (3) 如何配置一个安全的Apache服务器 (3) 勤打补丁 (3) 建立一个安全的目录结构 (5) 为Apache使用专门的用户和用户组 (5) Web目录的访问策略 (6) 禁止使用目录索引 (6) 禁止默认访问 (6) 禁止用户重载 (6) 配置Apache服务器访问日志 (7) 相关配置文件说明 (7) Web服务器日志轮循 (8) Apache服务器的密码保护 (9) 减少CGI和SSI风险 (11) 使用SSL加固Apache (12) Apache服务器防范DoS攻击 (13)
Apache服务器面临的安全问题 HTTP拒绝服务 攻击者通过某种手段使服务器拒绝对HTTP应答。这使得Apache服务器对系统资源（cpu与内存）需求剧增，最终导致造成系统变慢甚至瘫痪。Apache服务器最大的缺点是他的普及性成为了众矢之的。Apache服务器所面临的拒绝服务攻击主要包括以下几种形式。 数据包洪水工具 1.一种中断服务器或者本地网络的方法是数据包洪水攻击，它通常使用 Internet控制报文协议（ICMP）包或者UDP包。在最简单的情况下，这些攻击都是使服务器或者网络的负载过重，这意味着黑客的网络攻击速度必须比目标的网络速度更快。使用UDP包的优势是不会有任何包返回到黑客的主机。而使用ICMP的优势是使得黑客的攻击更加富有变化。发送有缺陷的包会搞乱并锁住受害者的网络。目前所流行的趋势是黑客欺骗目标服务器，让其相信正在受到来自自身的洪水攻击。 2.磁盘攻击 这是一种更麻烦的攻击，它不仅仅影响目标计算机的通信，还破坏他的硬件。 伪造的用户请求利用写命令攻击目标服务器的硬盘，让其超过极限，并强制关闭。 受攻击者会因为信息暂时不可达，甚至丢失而产生损失。 3.路由不可达 通常，拒绝服务攻击集中在路由器上，攻击者首先获得控制权并操纵目标主机。 当攻击者能够更改路由器的路由表时，会造成整个网络不可达。这种攻击非常阴险，因为它刚开始出现时会让人莫名其妙。因为随后你的服务器就会失效，而整个网络又会不可达，这样你会要调查很多地方。 4.分布式拒绝攻击 这是对Apache服务器最有威胁的工具，即DDoS。当很多堡垒主机被感染时，一起向你的服务器发起拒绝服务攻击，是招架不住的。其中，繁衍式攻击是最恶劣的，因为攻击程序不会通过人为干涉而蔓延。Apache服务器特别容易受到攻击，无论是对分布式攻击还是隐藏来源的工具。原因是Apache服务器无处不在，对于Apache 服务器所制定的病毒，特别是ssl蠕虫潜伏在很多主机上，黑客可以通过操纵蠕虫，
实验报告---apache服务器配置 一、实验目的： Apache源于NCSAhttpd服务器，经过多次修改，成为世界上最流行的Web 服务器软件之一。本来它只用于小型或试验Internet网络，后来逐步扩充到各种Unix系统中，尤其对Linux的支持相当完美。Apache有多种产品，可以支持SSL技术，支持多个虚拟主机。Apache的开发遵循GPL协议，由全球志愿者一起开发并维护。它的成功之处主要在于它的源代码开放、有一支开放的开发队伍、支持跨平台的应用（可以运行在几乎所有的Unix、Windows、Linux系统平台上）以及它的可移植性等方面。 支持最新的HTTP1.1通信协议；强大的可配置性和可扩展性；提供全部源代码和不受限制的使用许可；通过第三方模块可以支持Java Servlets；广泛的应用和支持多种平台。 因此做这个实验的目的是为了熟悉apache服务器的配置，通过实验来加深对它的了解。 二、实验内容： （一）、Apache服务器的安装、启动与停止 （二）、配置用户个人主页 （三）、配置虚拟主机：a、创建基于IP地址的虚拟主机 b、创建基于域名的虚拟主机 三、实验步骤： （一）Apache服务器的安装、启动及访问 1.检验apache服务的软件包是否安装，默认情况下是没有安装的，因此需安装。 # rpm -qa|grep httpd //检验软件包是否安装 # mount /dev/cdrom /mnt/cdrom //加载光驱 # cd /mnt/cdrom/Server //进入光盘的Server目录 # rpm -ivh postgresql-libs-8.1.18-2.e15_4.1.i386.rpm //安装所需要的RPM包 # rpm -ivh apr-1.2.7-11.e15_3.1.i386.rpm # rpm -ivh apr-util-1.2.7-11.e15.i386.rpm # rpm -ivh httpd-2.0.40-21.i386.rpm 注意：由于安装apache软件包有依赖关系，因此按照上述顺序进行安装 2.检验网络的连通性
web服务器apache架构与原理 web服务器 在开始了解Apache前，我们先熟悉一下web服务器，因为apache也是web服务器的一种。 Web系统由客户端（浏览器）和服务器端两部分组成。Web系统架构也被称为B/S架构。最常见的Web服务器有Apache、IIS等，常用的浏览器有IE、Firefox、chrome等。当你想访问一个网页时，需要在浏览器的地址栏中输入该网页的URL（Uniform Resource Locator，简称为URL）地址，或者是通过超链接链接到该网页。浏览器会向该网页所在的服务器发送一个HTTP请求，服务器会对接收到的请求信息进行处理，然后将处理的结果返回给浏览器，最终将浏览器处理后的结果呈现给用户。 web服务器端的工作流程： （1）客户端发送请求 客户端（通过浏览器）和Web服务器建立TCP连接，连接建立以后，向Web服务器发出访问请求（如get）。根据HTTP协议，该请求中包含了客户端的IP地址、浏览器的类型和请求的URL等一系列信息。 （2）服务器解析请求 Web服务器对请求按照HTTP协议进行解码来确定进一步的动作，设计的内容有三鼐要点：方法（GET）、文档(/sample.html)、和浏览器使用的协议（HTTP/1.1）其中方法告诉服务器应完动的动作，GET方法的含义很明显是：服务器应定位、读取文件并将它返回给客户。 Web服务器软件现在就知道了，它应该找到文件/sample.html，并使用HTTP/1.1协议将内存返回给客户。信息是经过与请求到来相同的连接发出的，所以服务器不需要定们客户或创建新的连接。 （3）读取其它信息（非必须步骤）
Apache服务器配置及安全应用指南 技术创新变革未来
Apache服务安全加固 一.账号设置 以专门的用户帐号和组运行Apache。 根据需要为Apache 创建用户、组 参考配置操作如果没有设置用户和组，则新建用户，并在Apache 配置文件中指定 (1) 创建apache 组：groupadd apache (2) 创建apache 用户并加入apache 组：useradd apache –g apache (3) 将下面两行加入Apache 配置文件httpd.conf中 检查httpd.conf配置文件。检查是否使用非专用账户(如root)运行apache 默认一般符合要求，Linux下默认apache或者nobody用户，Unix默认为daemon用户
Apache服务安全加固 授权设置 严格控制Apache主目录的访问权限，非超级用户不能修改该目录中的内容 Apache 的主目录对应于Apache Server配置文件httpd.conf的Server Root控制项中应为： 判定条件 非超级用户不能修改该目录中的内容 检测操作 尝试修改，看是否能修改 一般为/etc/httpd目录，默认情况下属主为root:root，其它用户不能修改文件，默认一般符合要求 严格设置配置文件和日志文件的权限，防止未授权访问。 chmod600 /etc/httpd/conf/httpd.conf”设置配置文件为属主可读写，其他用户无权限。 使用命令”chmod644 /var/log/httpd/*.log”设置日志文件为属主可读写，其他用户只读权限。 /etc/httpd/conf/httpd.conf默认权限是644，可根据需要修改权限为600。 /var/log/httpd/*.log默认权限为644，默认一般符合要求。
一．软件介绍(apache lighttpdnginx) 1. lighttpd Lighttpd是一个具有非常低的内存开销，cpu占用率低，效能好，以及丰富的模块等特点。lighttpd是众多OpenSource轻量级的web server中较为优秀的一个。支持FastCGI, CGI, Auth, 输出压缩(output compress), URL重写, Alias等重要功能。 Lighttpd使用fastcgi方式运行php,它会使用很少的PHP进程响应很大的并发量。 Fastcgi的优点在于： ·从稳定性上看, fastcgi是以独立的进程池运行来cgi,单独一个进程死掉,系统可以很轻易的丢弃,然后重新分配新的进程来运行逻辑. ·从安全性上看, fastcgi和宿主的server完全独立,fastcgi怎么down也不会把server搞垮, ·从性能上看, fastcgi把动态逻辑的处理从server中分离出来, 大负荷的IO处理还是留给宿主server, 这样宿主server可以一心一意作IO,对于一个普通的动态网页来说, 逻辑处理可能只有一小部分, 大量的图片等静态IO处理完全不需要逻辑程序的参与(注1) ·从扩展性上讲, fastcgi是一个中立的技术标准, 完全可以支持任何语言写的处理程序(php,java,python...) 2.apache apache是世界排名第一的web服务器, 根据netcraft(https://www.doczj.com/doc/615934088.html,)所作的调查,世界上百分之五十以上的web服务器在使用apache. 1995年4月, 最早的apache(0.6.2版)由apache group公布发行. apache group 是一个完全通过internet进行运作的非盈利机构, 由它来决定apache web服务器的标准发行版中应该包含哪些内容. 准许任何人修改隐错, 提供新的特征和将它移植到新的平台上, 以及其它的工作. 当新的代码被提交给apache group 时, 该团体审核它的具体内容, 进行测试, 如果认为满意, 该代码就会被集成到apache的主要发行版中. apache 的特性: 1) 几乎可以运行在所有的计算机平台上. 2) 支持最新的http/1.1协议 3) 简单而且强有力的基于文件的配置(httpd.conf). 4) 支持通用网关接口(cgi) 5) 支持虚拟主机. 6) 支持http认证. 7) 集成perl. 8) 集成的代理服务器 9) 可以通过web浏览器监视服务器的状态, 可以自定义日志. 10) 支持服务器端包含命令(ssi). 11) 支持安全socket层(ssl).
在Linux下配置Apache服务器 ——江湖、孙中霞、李琴一、实验目的 完成本次实训，将能够: ●配置基本的Apache服务器 ●配置个人用户Web站点。 ●配置虚拟目录别名功能。 ●配置主机访问控制。 ●配置用户身份验证功能.。 ●配置基于IP地址的虚拟主机. 二、实验环境 1、RedHat Linux4AS. 2、Apache 2.0 三、实验内容 1.配置基本的Apache服务器 2.配置个人用户Web站点。 3.配置虚拟目录别名功能。 4.配置主机访问控制。 5.配置用户身份验证功能.。 6.配置基于IP地址的虚拟主机。 四、实验要求 在Linux操作系统下配置Apache服务器。 五、注意事项 1.在修配置文件下注意区分大小写、空格。 2.在每次重新开机后都必须启动Apachec服务器。 3.在每次修改完主配置文件后保存起来，必须重启Apachec服务器，如果不重启会 导致配置无效，最终导致实验失败。 六、实验步骤 1、检测是否安装了Apache软件包: A、首先为服务器网卡添加一个固定的IP地址。 B、在Web浏览器的地址栏中输入本机的IP地址，若出现Test Page测试页面（该 网页文件的默认路径为var/www/html/index.html）如下图1所示就说明Apache 已安装并已启动。
另一种方法是使用如下命令查看系统是否已经安装了Apache软件包： [root@rhe14~]# rpm –aq | grep httpd Httpd-suexec-2.0.52-9.ent Httpd-manual-2.0.52-9.ent System-config-httpd-1.3.1-1 Httpd-devel-2.0.52-9.ent 出现以上内容表明了系统已安装Apache软件包。 2、安装Apache软件包 超级用户（root）在图形界面下选择“应用程序”|“系统设置”|“添加/删除应用程序”命令，选择“万维网服务器”软件包组，在单击“更新”按钮就可以安装与Apache相关的软件包。 3、Apache的基本配置 （1）打开终端输入[root@rhe14~]# /etc/rc.d/init.d/httpd start //启动Apache 或者 [root@rhe14~]# apachectl start //启动Apache [root@rhe14~]# apachectl stop //停止Apache服务 [root@rhe14~]# apachectl restart //重启Apache服务 [root@rhe14~]# apachectl configtest //测试Apache服务器配置语法（2）在httpd.conf将Apache的基本配置参数修改、将一些注释的语句取消注释，或将某些不需要的参数注释掉。 （3）将包括index.html在内的相关网页文件复制到指定的Web站点根目下（var/www/html/index.html） （4）重启httpd进程 (5) 在Web浏览器下输入配置的ip地址出现如下图2，那表明基本配置成功了: