Spring基础、IOC(控制反转)、AOP(面向切面编程)、Log4j、注解配置



学习示例代码，包含本篇介绍的spring常用操作示例和所有所需jar文件下载地址：http://download.csdn.net/detail/daijin888888/9556697

1.什么是Spring，有什么作用

 --Spring框架属于一个解决方案框架，可以对其他技术和框架进行整合应用。
 --*好处是：将程序中的各个组件和框架技术进行解耦，便于日后系统维护，升级和扩展操作。
 --在SSH中，会将Action，DAO组件都交给Spring框架管理，由Spring框架创建这些对象，建立这些对象关联。

*2.Spring都含有哪些功能

 --Spring框架提供了一个核心容器，该容器可以负责管理程序中的DAO、Action等组件(相当于工厂的作用)
 --提供了对其他技术，例如JDBC，Hibernate，Struts等框架整合API
 --提供了IOC机制，实现组件对象关系的解耦
 --提供了AOP机制，可以降低共通组件和一批目标组件的耦合度
 --提供了事务管理功能
 --提供了一个Spring MVC框架实现

*3.Spring框架容器

  Spring框架容器可以管理DAO、Action等Bean组件。该容器具有以下功能：
 --可以创建Bean组件对象
 --可以初始化Bean组件对象
 --可以销毁Bean组件对象
 --容器具有IOC和AOP机制

*4.Spring基本使用

  1)创建和管理程序组件对象
   --引入Spring IOC开发包（commons-logging.jar、spring.jar）
   --在src下添加Spring配置文件applicationContext.xml
   --将Bean组件定义到Spring配置文件applicationContext.xml中
    <bean id="标识符" class="包名.类名"></bean>
   --(编码)实例化Spring容器对象利用getBean获取Bean对象实例
      // 实例化Spring容器对象
    String conf = "/applicationContext.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
    // 从容器中获取Bean

    类名 对象名 = (类名) ac.getBean("标识符");

示例：

[java] view plain copy print?

1. public class JdbcCostDao implements CostDao {  
2.   
3.     public JdbcCostDao() {  
4.         System.out.println("JdbcCostDao构造");  
5.     }  
6.   
7.     public void init() {  
8.         System.out.println("初始化JdbcCostDao");  
9.     }  
10.   
11.     @Override  
12.     public void save() {  
13.         System.out.println("采用jdbc保存对象");  
14.     }  
15.   
16.     @Override  
17.     public void delete() {  
18.         String s = null;  
19.         s.length();// 模拟异常  
20.         System.out.println("采用jdbc删除对象");  
21.     }  
22.   
23.     public void destory() {  
24.         System.out.println("释放资源");  
25.     }  
26. }  

public class JdbcCostDao implements CostDao {    public JdbcCostDao() {        System.out.println("JdbcCostDao构造");    }    public void init() {        System.out.println("初始化JdbcCostDao");    }    @Override    public void save() {        System.out.println("采用jdbc保存对象");    }    @Override    public void delete() {        String s = null;        s.length();// 模拟异常        System.out.println("采用jdbc删除对象");    }    public void destory() {        System.out.println("释放资源");    }}

[html] view plain copy print?

1. <bean id="jdbcCostDao" scope="singleton" init-method="init"  
2.      destroy-method="destory" class="com.test.dao.JdbcCostDao"></bean>  

<bean id="jdbcCostDao" scope="singleton" init-method="init"     destroy-method="destory" class="com.test.dao.JdbcCostDao"></bean>

[java] view plain copy print?

1. // 测试回收  
2. @Test  
3. public void test2() {  
4.     // 实例化Spring容器对象  
5.     String conf = "/applicationContext.xml";  
6.     AbstractApplicationContext ac = new ClassPathXmlApplicationContext(conf);  
7.   
8.     // 从容器中获取Bean  
9.     CostDao costDao = (CostDao) ac.getBean("jdbcCostDao");  
10.     costDao.save();  
11.   
12.     ac.close();// 释放容器对象-->触发释放Bean对象-->触发destory-method方法  
13. }  

// 测试回收@Testpublic void test2() {// 实例化Spring容器对象String conf = "/applicationContext.xml";AbstractApplicationContext ac = new ClassPathXmlApplicationContext(conf);// 从容器中获取BeanCostDao costDao = (CostDao) ac.getBean("jdbcCostDao");costDao.save();ac.close();// 释放容器对象-->触发释放Bean对象-->触发destory-method方法}

运行结果：

[plain] view plain copy print?

1. 采用jdbc保存对象  
2. 释放资源  

采用jdbc保存对象释放资源

   *a.控制Bean对象创建模式
       在使用时，可以在<bean>定义部分利用scope属性指定bean对象采用单例模式创建还是原型模式创建。
    scope="singleton"表示单例模式(默认值)
    scope="prototype"表示原型模式，每次调用getBean都返回一个新的Bean对象。
    如果应用Web程序中，通过配置可以扩展出request，session等属性值
   b.控制Bean对象创建时机
    scope="singleton"时，Bean对象是在容器实例化时创建。在<bean>中使用lazy-init="true"可以将Bean创建推迟到getBean方法。
     scope="prototype"时，Bean对象是在getBean方法时创建。
   c.追加初始化和销毁方法
      在<bean>中利用init-method指定一个初始化方法。可以在对象创建之后自动调用。
      <bean init-method="myinit">创建Bean对象后，会自动执行myinit方法。
    同理，可以通过destroy-method属性指定方法名。当对象被垃圾回收前自动调用该方法执行资源释放工作。该属性仅适用于singleton模式的Bean对象，当执行Spring容器close()时，容器会释放Bean单例对象，会触发destroy-method="mydestroy"中的mydesctory方法。

*5.Spring的核心IoC容器

  a.IoC概念
  Inversion of Control 控制反转或反向控制（控制转移）
  2004 Martin fowler提出的IoC思想。IOC解决两个Bean组件调用问题，可以降低两个Bean组件对象之间的耦合度。所谓控制指的是对象的创建、初始化和销毁过程。当一个组件发生变更后，该逻辑需要响应修改，控制反转确切讲应该是控制的转移，意思是将控制逻辑由使用一方转移到第三框架或容器负责。当再发生组件变更后，只需要修改框架或容器配置，不需要修改关联组件。
  IoC思想：两个组件之间调用(例如A调用B)，原有方式是A负责创建B对象；现在变成了B对象由第三方框架或容器负责实例化，然后给A对象注入。即A对象获取B对象的方式发生了反转。
  IoC技术方案有两种：依赖注入（DI:Dependency Injection）和依赖查找
  Spring采用依赖注入技术实现IoC控制。
  依赖技术主要以下两种方式：
  --set方式注入(推荐)
    在A中定义setB(B b),接收传进来的B对象
  --构造方式注入
    在A中定义构造方法 public A(B b){}
  b.IoC使用方法(setter注入实现)
  --编写Action,定义到Spring配置中
  --编写DAO,定义到Spring配置中
  --在Action中定义DAO接口类型变量和setter方法
  --在Action的<bean>配置中使用下面配置
   <bean id="addCostAction"...>
     <property name="属性名"   ref="要注入的Bean对象id值">

     </property>

   </bean>

    示例：

[java] view plain copy print?

1. public class AddCostAction {  
2.   
3.     // 属性（略）  
4.     // 定义注入属性  
5.     private CostDao costDao;  
6.   
7.     public CostDao getCostDao() {  
8.         return costDao;  
9.     }  
10.   
11.     // Spring容器会自动调用该方法注入costDao  
12.     public void setCostDao(CostDao costDao) {  
13.         this.costDao = costDao;  
14.     }  
15.   
16.     public String exeucte() {  
17.         System.out.println("开始处理资费添加请求");  
18.         // CostDao costDao = new JdbcCostDao();//采用注入的方式替代直接生成，以此解耦  
19.         costDao.save();  
20.         return "success";  
21.     }  
22. }  

public class AddCostAction {// 属性（略）// 定义注入属性private CostDao costDao;public CostDao getCostDao() {return costDao;}// Spring容器会自动调用该方法注入costDaopublic void setCostDao(CostDao costDao) {this.costDao = costDao;}public String exeucte() {System.out.println("开始处理资费添加请求");// CostDao costDao = new JdbcCostDao();//采用注入的方式替代直接生成，以此解耦costDao.save();return "success";}}

applicationContext.xml中配置：

[java] view plain copy print?

1. <bean id="hibernateCostDAO" class="com.test.dao.HibernateCostDAO"></bean>  
2.   
3. <bean id="addCostAction" scope="prototype" class="com.test.action.AddCostAction">  
4.     <!-- setter注入配置，将hibernateCostDAO对象给action的setCostDao方法传入 -->  
5.     <property name="costDao" ref="hibernateCostDAO"></property>  
6. </bean>  

<bean id="hibernateCostDAO" class="com.test.dao.HibernateCostDAO"></bean><bean id="addCostAction" scope="prototype" class="com.test.action.AddCostAction"><!-- setter注入配置，将hibernateCostDAO对象给action的setCostDao方法传入 --><property name="costDao" ref="hibernateCostDAO"></property></bean>

  c.IoC使用方法(构造方式注入实现)
   --编写Action组件
   --编写DAO组件
   --在Action中添加带有DAO参数的构造方法
   --在Action的<bean>定义中，使用下面配置
    <bean id="deleteCostAction" class="">
       <constructor-arg
          index="参数索引值,从0开始" ref="要注入的Bean对象id值">
       </constructor-arg>

    </bean>

    示例：

[java] view plain copy print?

1. public class DeleteCostAction {  
2.     private CostDao costDao;  
3.   
4.     public DeleteCostAction() {  
5.   
6.     }  
7.   
8.     public DeleteCostAction(CostDao costDao) {  
9.         this.costDao = costDao;  
10.     }  
11.   
12.     public String exeucte() {  
13.         System.out.println("删除资费请求的处理");  
14.         costDao.delete();  
15.         return "success";  
16.   
17.     }  
18. }  

public class DeleteCostAction {private CostDao costDao;public DeleteCostAction() {}public DeleteCostAction(CostDao costDao) {this.costDao = costDao;}public String exeucte() {System.out.println("删除资费请求的处理");costDao.delete();return "success";}}

applicationContext.xml中配置：

[html] view plain copy print?

1. <bean id="jdbcCostDao" scope="singleton" init-method="init"  
2.     destroy-method="destory" class="com.test.dao.JdbcCostDao"></bean>  
3.   
4. <bean id="deleteCostAction" class="com.test.action.DeleteCostAction">  
5.     <!-- 构造参数注入配置，将jdbcCostDao对象给action的构造方法的第一个参数传入 -->  
6.     <constructor-arg index="0" ref="jdbcCostDao"></constructor-arg>  
7. </bean>  

<bean id="jdbcCostDao" scope="singleton" init-method="init"destroy-method="destory" class="com.test.dao.JdbcCostDao"></bean><bean id="deleteCostAction" class="com.test.action.DeleteCostAction"><!-- 构造参数注入配置，将jdbcCostDao对象给action的构造方法的第一个参数传入 --><constructor-arg index="0" ref="jdbcCostDao"></constructor-arg></bean>

   d.各种类型数据的注入
   --注入Bean对象(重点)
     <property name="属性名"  ref="Bean对象id">
     </property>
   --注入基本类型
    可以注入一个数值，一个字符串数据。
     <property name="属性名"  value="值">
     </property>
   --集合类型
    注入List,Set,Map,Properties类型

    示例：

[html] view plain copy print?

1. <bean id="messagebean" class="com.test.action.MessageBean">  
2.     <property name="dir" value="D:\\images\"></property>  
3.     <property name="size" value="10240"></property>  
4.     <!-- 注入List -->  
5.     <property name="types">  
6.         <list>  
7.             <value>jpg</value>  
8.             <value>jpeg</value>  
9.             <value>gif</value>  
10.         </list>  
11.     </property>  
12.     <!-- 注入Set -->  
13.     <property name="cites">  
14.         <set>  
15.             <value>北京</value>  
16.             <value>上海</value>  
17.             <value>广州</value>  
18.         </set>  
19.     </property>  
20.     <!-- 注入Map -->  
21.     <property name="books">  
22.         <map>  
23.             <entry key="1001" value="Java语言基础"></entry>  
24.             <entry key="1002" value="JavaWeb基础"></entry>  
25.             <entry key="1003" value="SSH框架技术"></entry>  
26.         </map>  
27.     </property>  
28.     <!-- 注入Properties -->  
29.     <property name="dbParams">  
30.         <props>  
31.             <prop key="username">root</prop>  
32.             <prop key="password">123456</prop>  
33.             <prop key="driverClassName">com.mysql.jdbc.Driver</prop>  
34.         </props>  
35.     </property>  
36. </bean>  

<bean id="messagebean" class="com.test.action.MessageBean"><property name="dir" value="D:\\images\"></property><property name="size" value="10240"></property><!-- 注入List --><property name="types"><list><value>jpg</value><value>jpeg</value><value>gif</value></list></property><!-- 注入Set --><property name="cites"><set><value>北京</value><value>上海</value><value>广州</value></set></property><!-- 注入Map --><property name="books"><map><entry key="1001" value="Java语言基础"></entry><entry key="1002" value="JavaWeb基础"></entry><entry key="1003" value="SSH框架技术"></entry></map></property><!-- 注入Properties --><property name="dbParams"><props><prop key="username">root</prop><prop key="password">123456</prop><prop key="driverClassName">com.mysql.jdbc.Driver</prop></props></property></bean>

对应接收注入的Java文件：

[java] view plain copy print?

1. /** 
2.  * @Description:测试注入数据类别 
3.  * 
4.  */  
5. public class MessageBean {  
6.   
7.     private String dir;  
8.     private int size;  
9.     private List<String> types;  
10.     private Set<String> cites;  
11.     private Map<String, String> books;  
12.     private Properties dbParams;  
13.   
14.     public List<String> getTypes() {  
15.         return types;  
16.     }  
17.   
18.     public void setTypes(List<String> types) {  
19.         this.types = types;  
20.     }  
21.   
22.     public String getDir() {  
23.         return dir;  
24.     }  
25.   
26.     public void setDir(String dir) {  
27.         this.dir = dir;  
28.     }  
29.   
30.     public int getSize() {  
31.         return size;  
32.     }  
33.   
34.     public void setSize(int size) {  
35.         this.size = size;  
36.     }  
37.   
38.     public Set<String> getCites() {  
39.         return cites;  
40.     }  
41.   
42.     public void setCites(Set<String> cites) {  
43.         this.cites = cites;  
44.     }  
45.   
46.     public Map<String, String> getBooks() {  
47.         return books;  
48.     }  
49.   
50.     public void setBooks(Map<String, String> books) {  
51.         this.books = books;  
52.     }  
53.   
54.     public Properties getDbParams() {  
55.         return dbParams;  
56.     }  
57.   
58.     public void setDbParams(Properties dbParams) {  
59.         this.dbParams = dbParams;  
60.     }  
61.   
62.     public void show() {  
63.         System.out.println("--显示注入参数--");  
64.         System.out.println("dir:" + dir);  
65.         System.out.println("size:" + size);  
66.         System.out.println("允许上传的类型如下：");  
67.         for (String s : types) {  
68.             System.out.println(s);  
69.         }  
70.         System.out.println("城市信息：");  
71.         for (String s : cites) {  
72.             System.out.println(s);  
73.         }  
74.         System.out.println("图书信息:");  
75.         Set<Entry<String, String>> book = books.entrySet();  
76.         for (Entry en : book) {  
77.             System.out.println(en.getKey() + ":" + en.getValue());  
78.         }  
79.         System.out.println("显示数据库连接参数：");  
80.         Set keys = dbParams.keySet();  
81.         for (Object key : keys) {  
82.             System.out  
83.                     .println(key + "=" + dbParams.getProperty(key.toString()));  
84.         }  
85.     }  
86. }  

/** * @Description:测试注入数据类别 * */public class MessageBean {private String dir;private int size;private List<String> types;private Set<String> cites;private Map<String, String> books;private Properties dbParams;public List<String> getTypes() {return types;}public void setTypes(List<String> types) {this.types = types;}public String getDir() {return dir;}public void setDir(String dir) {this.dir = dir;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}public Set<String> getCites() {return cites;}public void setCites(Set<String> cites) {this.cites = cites;}public Map<String, String> getBooks() {return books;}public void setBooks(Map<String, String> books) {this.books = books;}public Properties getDbParams() {return dbParams;}public void setDbParams(Properties dbParams) {this.dbParams = dbParams;}public void show() {System.out.println("--显示注入参数--");System.out.println("dir:" + dir);System.out.println("size:" + size);System.out.println("允许上传的类型如下：");for (String s : types) {System.out.println(s);}System.out.println("城市信息：");for (String s : cites) {System.out.println(s);}System.out.println("图书信息:");Set<Entry<String, String>> book = books.entrySet();for (Entry en : book) {System.out.println(en.getKey() + ":" + en.getValue());}System.out.println("显示数据库连接参数：");Set keys = dbParams.keySet();for (Object key : keys) {System.out.println(key + "=" + dbParams.getProperty(key.toString()));}}}

测试程序：

[java] view plain copy print?

1. public class TestMessageBean {  
2.   
3.     @Test  
4.     public void test1() {  
5.         String conf = "/applicationContext.xml";  
6.         ApplicationContext ac = new ClassPathXmlApplicationContext(conf);  
7.   
8.         MessageBean bean = (MessageBean) ac.getBean("messagebean");  
9.         bean.show();  
10.     }  
11. }  

public class TestMessageBean {@Testpublic void test1() {String conf = "/applicationContext.xml";ApplicationContext ac = new ClassPathXmlApplicationContext(conf);MessageBean bean = (MessageBean) ac.getBean("messagebean");bean.show();}}

测试结果：

[plain] view plain copy print?

1. --显示注入参数--  
2. dir:D:\\images\  
3. size:10240  
4. 允许上传的类型如下：  
5. jpg  
6. jpeg  
7. gif  
8. 城市信息：  
9. 北京  
10. 上海  
11. 广州  
12. 图书信息:  
13. 1001:Java语言基础  
14. 1002:JavaWeb基础  
15. 1003:SSH框架技术  
16. 显示数据库连接参数：  
17. password=123456  
18. driverClassName=com.mysql.jdbc.Driver  
19. username=root  

--显示注入参数--dir:D:\\images\size:10240允许上传的类型如下：jpgjpeggif城市信息：北京上海广州图书信息:1001:Java语言基础1002:JavaWeb基础1003:SSH框架技术显示数据库连接参数：password=123456driverClassName=com.mysql.jdbc.Driverusername=root

6.Spring的AOP机制

 1)什么是AOP，解决什么问题
  --Aspect Oriented Programming被称为面向方面(切面)编程。
  --AOP主要解决共通组件与某一批目标组件作用关系，以低耦合方式建立关联。
  --AOP编程核心是对方面处理（共通功能)进行解耦。OOP编程核心是对象。
  --AOP编程是以OOP为基础，在OOP基础之上改善程序中对象结构，使得对象关系更加灵活，易于维护和扩展。
 
 2)AOP相关概念
  a.方面(Aspect)：
    方面封装了共通处理，在AOP编程中，可以灵活作用到另外一批目标组件的方法上。
  b.切入点(Pointcut)
   切入点负责指定哪些组件和方法，是方面切入的目标。采用一个表达式指定
  c.通知(Advice)
   通知负责指定切入点和目标组件方法之间的作用时机。例如先执行目标方法，再执行方面处理。或者先执行方面处理，再执行目标方法。
   Spring提供以下5种通知类型：
  --前置通知(aop:before):先执行方面处理，再执行目标方法
  --后置通知(aop:after-returning):先执行目标方法，未抛出异常，再执行方面处理；有异常则不会执行方面组件
  --最终通知(aop:after):先执行目标方法，有无异常，都会再执行方面处理
  --环绕通知(aop:around):先执行方面处理前置部分，接着执行目标方法，然后再回到方面处理的后置部分。
  --异常通知(aop:after-throwing):先执行目标方法，发生异常再执行方面处理；没有抛出异常不会执行。
 try{
  //前置通知--执行方面处理
  //环绕的前置部分
  执行目标方法
  //环绕的后置部分
  //后置通知--执行方面处理
 }catch(){
   //异常通知--执行方面处理
  }finally{
   //最终通知--执行方面处理
  }
  d.目标组件(Target)
    切入点表达式指定的组件就是目标组件。
  e.连接点(JoinPoint)
    连接点的集合是切入点。连接点指的是方面组件与某个目标组件相结合的信息。通过该对象可以获取目标组件类型和方法等信息。
  f.动态代理(AutoProxy)
   Spring框架采用动态代理技术实现了AOP机制。
  当采用了AOP之后，Spring容器返回的目标Bean对象，是Spring动态生成的一个代理类型。该代理类负责去调用原目标组件方法和方面处理的功能。
  Spring中提供两种生成动态代理类的方法。
  --JDK Proxy API技术
    针对有接口实现的目标组件。采用实现原目标接口的方法生成一个类型。
   public class $Proxy4 implements CostDao{
     public void save(){
       //调用JdbcCostDao的save()
       //调用方面LoggerAop的功能
     }
     public void findAll(){
       //调用JdbcCostDao的findAll()
       //调用方面LoggerAop的功能
     }
  }
  --CGLIB技术
    针对没有接口实现的目标组件。采用继承方法生成一个子类。
  public class $$EnhancerByCGLIB$232 extends 原目标组件类型{
     public void save(){
       super.save();//调用原目标方法
       //调用方面组件处理
     }
  }

 3)AOP使用步骤
  a.记录用户进入系统后执行的操作
  --编写方面，将共通功能封装
  --添加Spring配置，将组件定义成方面组件
  --添加Spring配置，定义切入点
  --添加Spring配置，定义通知

方面代码：

[java] view plain copy print?

1. public class OptLogger {  
2.     /** 
3.      * @param pjp 
4.      *            连接点（需用环绕通知切入） 
5.      * @throws Throwable 
6.      */  
7.     public Object log(ProceedingJoinPoint pjp) throws Throwable {  
8.         Object obj = pjp.proceed();// 执行目标组件方法处理  
9.         // 获取当前请求要执行的Action目标组件类型  
10.         String className = pjp.getTarget().getClass().getName();  
11.         // 获取当前请求要执行的方法名  
12.         String methodName = pjp.getSignature().getName();  
13.         // 根据类名和方法名形成key  
14.         String key = className + "." + methodName;  
15.         // 解析opt.properties，根据key获取操作动作描述  
16.         String optName = PropertiesUtil.getProperty(key);  
17.   
18.         System.out.println("XXX在" + new Date() + "时间做了" + optName + "操作");  
19.         return obj;// 将proceed目标方法结果返回  
20.     }  
21. }  
22. PropertiesUtil用于读取配置文件，可将特定操作（类+方法转换成中文描述）  
23. <pre name="code" class="java">public class PropertiesUtil {  
24.     private static Properties props = new Properties();  
25.     static{  
26.         try{  
27.             InputStream inStream = PropertiesUtil.class  
28.                 .getClassLoader().getResourceAsStream(  
29.                         "opt.properties");  
30.             props.load(inStream);  
31.         }catch(Exception ex){  
32.             ex.printStackTrace();  
33.         }  
34.     }  
35.       
36.     public static String getProperty(String key){  
37.         String val = props.getProperty(key);  
38.         return val;  
39.     }  
40.       
41. }  

public class OptLogger {/** * @param pjp *            连接点（需用环绕通知切入） * @throws Throwable */public Object log(ProceedingJoinPoint pjp) throws Throwable {Object obj = pjp.proceed();// 执行目标组件方法处理// 获取当前请求要执行的Action目标组件类型String className = pjp.getTarget().getClass().getName();// 获取当前请求要执行的方法名String methodName = pjp.getSignature().getName();// 根据类名和方法名形成keyString key = className + "." + methodName;// 解析opt.properties，根据key获取操作动作描述String optName = PropertiesUtil.getProperty(key);System.out.println("XXX在" + new Date() + "时间做了" + optName + "操作");return obj;// 将proceed目标方法结果返回}}PropertiesUtil用于读取配置文件，可将特定操作（类+方法转换成中文描述）<pre name="code" class="java">public class PropertiesUtil {private static Properties props = new Properties();static{try{InputStream inStream = PropertiesUtil.class.getClassLoader().getResourceAsStream("opt.properties");props.load(inStream);}catch(Exception ex){ex.printStackTrace();}}public static String getProperty(String key){String val = props.getProperty(key);return val;}}

opt.properties：（使用native2ascii tool工具将中文转码）
#use jdk/bin/native2ascii tool
#以下分别对应：资费添加操作、资费删除操作
com.test.action.AddCostAction.exeucte=\u8d44\u8d39\u6dfb\u52a0\u64cd\u4f5c
com.test.action.DeleteCostAction.exeucte=\u8d44\u8d39\u5220\u9664\u64cd\u4f5c

配置代码：

[html] view plain copy print?

1. <!-- AOP配置 -->  
2. <bean id="optLogger" class="com.test.aspect.OptLogger">  
3. <aop:config>  
4.     <!-- 指定切入点 -->  
5.     <aop:pointcut id="actionPointcut" expression="within(com.test.action.*)" />  
6.     <!-- 将id=optLogger的Bean指定为方面组件 -->  
7.     <aop:aspect id="optLoggerAspect" ref="optLogger">  
8.         <!-- 指定通知，控制方面和目标组件作用时机 -->  
9.         <aop:around pointcut-ref="actionPointcut" method="log" />  
10.     </aop:aspect>  
11. </aop:config>  

<!-- AOP配置 --><bean id="optLogger" class="com.test.aspect.OptLogger"><aop:config><!-- 指定切入点 --><aop:pointcut id="actionPointcut" expression="within(com.test.action.*)" /><!-- 将id=optLogger的Bean指定为方面组件 --><aop:aspect id="optLoggerAspect" ref="optLogger"><!-- 指定通知，控制方面和目标组件作用时机 --><aop:around pointcut-ref="actionPointcut" method="log" /></aop:aspect></aop:config>

 4)切入点表达式
  切入点是用一个表达式表示，用于指定目标及其方法。
 *a.方法限定表达式
  可以指定哪些方法启用方面组件功能
 execution(修饰符? 返回类型 方法名(参数列表) throws异常?)
 示例1:
  //匹配容器中所有Bean对象的findAll方法
  execution(* findAll(..))
  //匹配容器中所有Bean对象的find开头方法
  execution(* find*(..))
 示例2:
  //匹配JdbcCostDao所有方法
  execution(* org.dao.JdbcCostDao.*(..))
 示例3:
  //匹配org.dao包下所有类的所有方法
  execution(* org.dao.*.*(..))
  //匹配org.dao包及其子包所有类所有方法
  execution(* org.dao..*.*(..))
 *b.类型限定表达式
 可以限定某个类型的所有方法启用方面within(类型)
 示例1：
  //匹配JdbcCostDao所有方法
  within(org.dao.JdbcCostDao)
 示例2：
  //匹配org.dao下所有类的所有方法
  within(org.dao.*)
 示例3：
  //匹配org.dao下及其子包所有类所有方法
  within(org.dao..*)
 *c.Bean名称限定表达式
 可以利用Bean对象的id进行限定
 bean(id或name值)
 <bean id="" name="">
 name属性作用与id相同，id要求更严格，不允许使用/等特殊字符，name允许。
 示例1:
  //匹配容器中所有id以Dao结尾的Bean对象
  bean(*Dao)
  d.参数限定表达式
  args(参数类型)
 示例1:
  //匹配所有Bean对象中有一个参数，而且是String类型的方法
   args(java.lang.String)

 提示：上述表达式可以利用&&,||连接在一起使用。

 5)通知方法定义
  //前置通知方法
  public void xxx(){}
  //后置通知方法
  public void xxx(Object retVal){}
  参数retVal可以接收目标方法返回值
  //最终通知方法
  public void xxx(){}
  *//环绕通知方法
  public Object xxx(ProceedingJoinPoint pjp){}
  *//异常通知方法
  public void xxx(Exception e){}
  参数e可以接收目标方法抛出的异常对象

（示例：如6中用Log4j记录程序异常信息并保存下来）

7.Log4j

  log4j.jar工具是Apache组织下的一个日志组件，可以将消息按不同级别不同输出方式记录下来。
  log4j工具主要有以下3部分构成。
  --日志器Logger
    负责提供输出不同级别消息的方法。消息可以分为调试、普通、警告、错误、致命级别，不同级别信息利用不同日志器的方法输出。
  --输出器Appender
    负责控制信息输出的方式，例如控制台输出、文件输出等。
  --布局器Layout

    负责将消息格式化。

    对应关系：一个Logger可以指定多个不同的Appender，每个Appender可以指定一个Layout。

  使用步骤：

  --引入log4j.jar开发包

  --在Java代码中获取Logger对象,之后利用它的debug(),error()输出信息

  --在src下添加log4j.properties配置文件指定消息输出的级别，输出的appender和输出的layout格式。

 提示：项目中由于SSH框架利用Log4j工具输出调试和异常信息，因此遇到错误提示不明确时，可以添加log4j.properties配置将级别调到DEBUG查看。

如配置文件，log4j.properties：

[plain] view plain copy print?

1. log4j.rootLogger=error,myconsole,myfile  
2.   
3. log4j.appender.myfile=org.apache.log4j.FileAppender  
4. log4j.appender.myfile.File=D:\\log4j.html  
5. log4j.appender.myfile.layout=org.apache.log4j.HTMLLayout  
6.   
7. log4j.appender.myconsole=org.apache.log4j.ConsoleAppender  
8. log4j.appender.myconsole.layout=org.apache.log4j.SimpleLayout  

log4j.rootLogger=error,myconsole,myfilelog4j.appender.myfile=org.apache.log4j.FileAppenderlog4j.appender.myfile.File=D:\\log4j.htmllog4j.appender.myfile.layout=org.apache.log4j.HTMLLayoutlog4j.appender.myconsole=org.apache.log4j.ConsoleAppenderlog4j.appender.myconsole.layout=org.apache.log4j.SimpleLayout

[java] view plain copy print?

1. /** 
2.  * @Description:异常记录方面组件 
3.  */  
4. public class ExceptionLogger {  
5.     // 获取日志器  
6.     private static Logger logger = Logger.getLogger(ExceptionLogger.class);  
7.   
8.     // ex就是目标方法抛出的异常对象  
9.     public void logException(Exception ex) {  
10.         // System.out.println("将异常写入文件" + ex);  
11.         // 采用Log4j日志工具记录异常信息  
12.         logger.error(ex);  
13.         logger.error(ex.getStackTrace()[0]);  
14.     }  
15. }  

/** * @Description:异常记录方面组件 */public class ExceptionLogger {// 获取日志器private static Logger logger = Logger.getLogger(ExceptionLogger.class);// ex就是目标方法抛出的异常对象public void logException(Exception ex) {// System.out.println("将异常写入文件" + ex);// 采用Log4j日志工具记录异常信息logger.error(ex);logger.error(ex.getStackTrace()[0]);}}

[html] view plain copy print?

1. <!-- AOP配置 -->  
2. <bean id="exceptionLogger" class="com.test.aspect.ExceptionLogger">  
3. </bean>  
4. <!-- 指定切入点 -->  
5. <aop:pointcut id="daoPointcut" expression="within(com.test.dao..*)" />  
6. <aop:config>  
7.     <!-- 将id=exceptionLogger的Bean指定为方面组件 -->  
8.     <!-- trowing指定logException方法的参数名，用于接收目标方法抛出的异常对象 -->  
9.     <aop:aspect id="exceptionLoggerAspect" ref="exceptionLogger">  
10.         <aop:after-throwing pointcut-ref="daoPointcut"  
11.             method="logException" throwing="ex" />  
12.     </aop:aspect>  
13. </aop:config>  

<!-- AOP配置 --><bean id="exceptionLogger" class="com.test.aspect.ExceptionLogger"></bean><!-- 指定切入点 --><aop:pointcut id="daoPointcut" expression="within(com.test.dao..*)" /><aop:config><!-- 将id=exceptionLogger的Bean指定为方面组件 --><!-- trowing指定logException方法的参数名，用于接收目标方法抛出的异常对象 --><aop:aspect id="exceptionLoggerAspect" ref="exceptionLogger"><aop:after-throwing pointcut-ref="daoPointcut"method="logException" throwing="ex" /></aop:aspect></aop:config>

在配置文件指定的地方生产文件如下：

[plain] view plain copy print?

1. D:\\log4j.html  

D:\\log4j.html

Log session start time Wed Jun 22 17:00:13 CST 2016

---

Log session start time Wed Jun 22 17:03:39 CST 2016

TimeThreadLevelCategoryMessage0mainERRORcom.test.aspect.ExceptionLoggerjava.lang.NullPointerException1mainERRORcom.test.aspect.ExceptionLoggercom.test.dao.JdbcCostDao.delete(JdbcCostDao.java:22)TimeThreadLevelCategoryMessage0mainERRORcom.test.aspect.ExceptionLoggerjava.lang.NullPointerException3mainERRORcom.test.aspect.ExceptionLoggercom.test.dao.JdbcCostDao.delete(JdbcCostDao.java:22)

8.Spring注解配置

 1)什么是注解
   注解技术是JDK5.0开始提供的。
   它的标记格式为"@名称"，它可以定义在类前、方法前、成员变量前。
 2)使用注解的好处
  现在的框架都提供了注解配置，利用注解技术去简化或替代原有的XML配置。
 3)Spring的组件扫描技术
  Spring可以自动扫描指定包下的Class组件,如果发现类定义前面有以下几个标记
  @Controller（Action组件应用）
  @Service（Service业务组件应用）
  @Repository（DAO组件应用）
  @Component（其他组件应用）
  就会将该组件扫描到Spring容器，由容器负责管理和对象的创建，等价于XML中<bean>定义。
  使用方法：
   --在applicationContext.xml中开启组件扫描功能 <context:component-scan base-package="指定包路径"/>
   --在Action或DAO等组件类定义前使用上述标记。默认用类名首字母小写当id，也可以采用@Repository("指定id")格式
  其他<bean>属性注解标记：
  @Scope("prototype"或"singleton")等价于scope属性
  @PreDestory等价于destory-method属性
  @PostConstruct等价于init-method属性
  4)注入的注解
    @Resource
    @Autowired
   上面两种标记都可以实现类型匹配注入，但是如果遇到多个匹配对象时，会发生异常。这时需要指定注入哪个id的Bean
    @Resource(name="指定id")
    @Autowired()
    @Qualifier("指定id")
   上面标记可以写在变量定义前或set方法前。写在变量定义前时，set可省略。
  5)AOP注解配置
   使用方法：
   --在applicationContext.xml中开启AOP的注解配置<aop:aspectj-autoproxy/>
   --在方面组件中类定义前使用下面标记
    @Component //将Bean扫描到容器
    @Aspect //将Bean升级为方面组件
   --在方面组件中定义一个空方法，利用@Point标记定义切入表达式
    @Pointcut("切入表达式")
    public void mypoint(){}
   --在方面组件处理方法上，使用下面通知标记
    @Before 前置通知标记
    @Around 环绕通知标记
    @AfterReturning 后置通知标记
    @AfterThrowing 异常通知标记
    @After 最终通知标记

源页：

本文转自-http://blog.csdn.net/daijin888888/article/details/51735291?locationNum=10&fps=1