zoukankan      html  css  js  c++  java
  • Spring AOP

    AOP
        1.将散布在系统中的公共功能,提取封装成独立的模块
        2.采用代理机制组装起来运行,在不改变原程序的基础上对代码段进行增强处理,增加新的功能

    先对Spring AOP里面几个名词进行说明。

    • 切面(Aspect)
      • 通知和切点的结合  
      • 切面使用通用类或者在普通类中加@AspectJ
    • 连接点(Join point)
      • 应用执行中插入切面的一个点
      • 调用方法,抛出异常,修改字段 
      • 方法执行 
    • 通知(Advice)
      • 切面的工作  
    • 切入点(Pointcut)
      • 匹配通知要织入的一个(以上)连接点
      • 类名,方法名指定  
    • 引入(Introduction)
      • 向现有类添加方法或属性  
    • 目标对象(Target Object)
      • 被一个(以上)切面通知的对象
      • 代理类  
    • 织入(Weaving)
      • 切面应用到目标对象,创建新的代理对象
      • 编译期,类加载期,运行期织入  

    目的
        1.A从系统中分离出切面,独立于业务逻辑实现,在程序执行时织入程序中运行

    • 切面,可重用的公共模块,比如,日志,事务等

        2.配置AOP主要使用aop命名空间下的元素完成。可以实现定义切入点和织入增强等操作

        3.Spring提供的增强处理类型包括:前置增强、后置增强、环绕增强、异常抛出增强、最终增强等

    作用
        1.实现系统日志功能
            a.业务介绍:将业务逻辑方法的调用信息输出到控制台
            b.AOP思路:分别编写业务逻辑代码和“增强”代码,运行时再组装
            c.步骤:
                1)添加jar包
                2)编写业务逻辑接口和实现类,编码时无需关心其他功能
            d.定义切入点
                1)public * addUser(com.xuetang9.demo.entity.User)
                2)public void *(com.xuetang9.demo.entity.User)
                3)public void addUser(..)                        不知道参数类型
                4)* com.xuetang9.demo.service.*.*(..)            service包所有的方法
                5)* com.xuetang9.demo.service..*.*(..)  等        service包及其子包所有的方法

        2.增强类型
            a.异常抛出增强:目标方法抛出异常时织入增强处理
                ThrowsAdvice接口中并没有定义任何方法,但是我们在定义异常抛出的增强方法时必须遵守以下方法签名:
                void afterThrowing ( [Method method, Object[] arguments, Object target) Throwable ex )
            注意:方法名必须是afterThrowing。方法的入参只有最后一个是必须的,前三个入参是可选的,但是前三个参数要么都提供,要么一个也不提供。正确的声明方法举例:
                1)afterThrowing(Method method, Object[] args, Object target, SQLException ex)
                2)afterThrowing(SQLException ex)
                3)afterThrowing(RuntimeException ex)
                错误的声明方法举例:
                    1)catchThrowing(RuntimeException ex):方法名错误
                    2)afterThrowing(Method method, RuntimeException ex):参数列表错误

            b.环绕增强:在目标方法的前后都可以织入增强处理
                1)功能最强大的增强处理,Spring把目标方法的控制权全部在它手中
                2)可以获取或修改目标方法的参数、返回值。可以对它进行异常处理,甚至可以决定目标方法是否执行
            c.前置增强
            d.后置增强
            e.最终增强

    范例:
    1.实体类及其配置文件
    a.实体类 -- User类

     1 package com.Elastic.SpringDemo2.ivy.entity;
     2 
     3 import java.io.Serializable;
     4 
     5 public class User implements Serializable {
     6     private String loginName;
     7     private String loginPass;
     8     
     9     public String getLoginName() {
    10         return loginName;
    11     }
    12     public void setLoginName(String loginName) {
    13         this.loginName = loginName;
    14     }
    15     public String getLoginPass() {
    16         return loginPass;
    17     }
    18     public void setLoginPass(String loginPass) {
    19         this.loginPass = loginPass;
    20     }
    21     
    22 }


    b.实体类配置文件 -- User.hbm.xml

     1 <?xml version="1.0"?>
     2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
     4 <!-- Generated 2016-7-5 22:38:24 by Hibernate Tools 3.4.0.CR1 -->
     5 <hibernate-mapping>
     6     <class name="com.Elastic.SpringDemo2.ivy.entity.User" table="user">
     7         <id name="loginName" type="java.lang.String">
     8             <column name="userName" />
     9             <generator class="assigned" />
    10         </id>
    11         <property name="loginPass" type="java.lang.String">
    12             <column name="passWord" />
    13         </property>
    14     </class>
    15 </hibernate-mapping>


    2.hibernate配置文件 -- hibernate.cfg.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-configuration PUBLIC
     3         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     4         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
     5 <hibernate-configuration>
     6     <session-factory>
     7         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
     8         <property name="hibernate.connection.password">root</property>
     9         <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernatedb</property>
    10         <property name="hibernate.connection.username">root</property>
    11         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    12  
    13           <property name="show_sql">true</property>
    14           <property name="format_sql">true</property>
    15  
    16           <mapping resource="com/Elastic/SpringDemo2/ivy/entity/User.hbm.xml"/>
    17     </session-factory>
    18 </hibernate-configuration>


    3.util包
    a.HibernateUtil类

     1 package com.Elastic.SpringDemo2.ivy.util;
     2 
     3 import org.hibernate.Session;
     4 import org.hibernate.SessionFactory;
     5 import org.hibernate.cfg.Configuration;
     6 public final class HibernateUtil {
     7     private static Configuration cfg = null;
     8     private static SessionFactory sessionFactory = null;
     9     
    10     //本地线程
    11     public static ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
    12     
    13     static{
    14         cfg = new Configuration().configure();
    15         sessionFactory = cfg.buildSessionFactory();
    16     }
    17     
    18     public static Session getSession(){
    19         Session session = threadLocal.get();
    20         if (null == session || !session.isOpen()) {
    21             session = sessionFactory.openSession();
    22             threadLocal.set(session);
    23         }
    24         return session;
    25     }
    26 }


    4.dao包
    a.IBaseDao接口

      1 package com.Elastic.SpringDemo2.ivy.dao;
      2 
      3 import java.io.Serializable;
      4 import java.util.List;
      5 import java.util.Map;
      6 
      7 import org.hibernate.Session;
      8 import org.hibernate.criterion.DetachedCriteria;
      9 public interface IBaseDao<T> {
     10     /**
     11      *
     12      * <p>
     13      * <h3>方法功能描述:获取Session对象</h3>
     14      * </p>
     15      * @return
     16      * @procedure 执行过程
     17      * @see IBaseDao
     18      */
     19     Session getSession();
     20     
     21     /**
     22      *
     23      * <p>
     24      * <h3>方法功能描述:保存数据</h3>
     25      * </p>
     26      * @param record    需要保存的对象
     27      * @procedure 执行过程
     28      * @see IBaseDao
     29      */
     30     void save(T record);
     31     
     32     /**
     33      *
     34      * <p>
     35      * <h3>方法功能描述:根据主键删除对应的数据</h3>
     36      * </p>
     37      * @param id
     38      * @procedure 执行过程
     39      * @see IBaseDao
     40      */
     41     //不明确id的类型,就用Serializable
     42     void delete(Serializable id);
     43     
     44     /**
     45      *
     46      * <p>
     47      * <h3>方法功能描述:根据数据对象删除数据库中对应的数据</h3>
     48      * </p>
     49      * @param record
     50      * @procedure 执行过程
     51      * @see IBaseDao
     52      */
     53     void delete(T record);
     54     
     55     /**
     56      *
     57      * <p>
     58      * <h3>方法功能描述:根据指定的对象修改对应的数据</h3>
     59      * </p>
     60      * @param record
     61      * @procedure 执行过程
     62      * @see IBaseDao
     63      */
     64     void update(T record);
     65     
     66     /**
     67      *
     68      * <p>
     69      * <h3>方法功能描述:根据主键查询对应的数据</h3>
     70      * </p>
     71      * @param id
     72      * @return 返回查找到的数据,如果没有返回null
     73      * @procedure 执行过程
     74      * @see IBaseDao
     75      */
     76     T findById(Serializable id);
     77     
     78     /**
     79      *
     80      * <p>
     81      * <h3>方法功能描述:根据指定的hql语句和参数查询语句</h3>
     82      * </p>
     83      * @param hql  需要执行的查询的HQL语句
     84      * @param params  执行的查询的HQL语句所需的参数,如果没有填写null
     85      * @return    返回查询数据的集合,如果出现异常返回null
     86      * @procedure 执行过程
     87      * @see IBaseDao
     88      */
     89     List<T> find(String hql,Map<String, Object> params);
     90     
     91     /**
     92      *
     93      * <p>
     94      * <h3>方法功能描述:根据指定的HQL语句和参数以及分页所需的数据执行查询</h3>
     95      * </p>
     96      * @param hql   需要执行的查询的HQL语句
     97      * @param pageIndex    需要查询的页数
     98      * @param pageSize    每页显示的数据条数
     99      * @param params    执行的查询的HQL语句所需的参数,如果没有填写null
    100      * @return    返回分页查询的结果,是一个Map对象,该对象包含<blockquote>
    101      *        <b>data</b>:查询结果的数据集合是一个List对象<br>
    102      *         <b>pageIndex</b>:当前查询的页数<br>
    103      *         <b>pageSize</b>:每页显示的数据条数<br>
    104      *         <b>total</b>:数据的总条数<br>
    105      *         <b>pageTotal</b>:数据的总页数<br>
    106      *         <b>hasPrev</b>:是否有上一条数据<br>
    107      *         <b>hasNext</b>:是否有下一条数据<br>
    108      *         </blockquote>
    109      * @procedure 执行过程
    110      * @see IBaseDao
    111      */
    112     Map<String, Object> find(String hql, int pageIndex, int pageSize, Map<String, Object> params);
    113     
    114     /**
    115      *
    116      * <p>
    117      * <h3>方法功能描述:分页查询数据</h3>
    118      * </p>
    119      * @param pageIndex    需要查询的页数
    120      * @param pageSize    每页显示的数据条数
    121      * @return    返回分页查询的结果,是一个Map对象,该对象包含<blockquote>
    122      *        <b>data</b>:查询结果的数据集合是一个List对象<br>
    123      *         <b>pageIndex</b>:当前查询的页数<br>
    124      *         <b>pageSize</b>:每页显示的数据条数<br>
    125      *         <b>total</b>:数据的总条数<br>
    126      *         <b>pageTotal</b>:数据的总页数<br>
    127      *         <b>hasPrev</b>:是否有上一条数据<br>
    128      *         <b>hasNext</b>:是否有下一条数据<br>
    129      *         </blockquote>
    130      * @procedure 执行过程
    131      * @see IBaseDao
    132      */
    133     Map<String, Object> find(int pageIndex, int pageSize);
    134     
    135     /**
    136      *
    137      * <p>
    138      * <h3>方法功能描述:根据DetachedCriteria 对象设置的条件查询数据,该功能不具备分页操作</h3>
    139      * </p>
    140      * @param detachedCriteria    需要设置的对象查询条件
    141      * @return    返回查询数据的集合,如果出现异常返回null
    142      * @procedure 执行过程
    143      * @see IBaseDao
    144      */
    145     List<T> find(DetachedCriteria detachedCriteria);
    146 
    147     
    148     /**
    149      *
    150      * <p>
    151      * <h3>方法功能描述:根据DetachedCriteria 对象设置的条件进行分页查询</h3>
    152      * </p>
    153      * @param detachedCriteria    需要设置的对象查询条件
    154      * @param pageIndex    需要查询的页数
    155      * @param pageSize    每页显示的数据条数
    156      * @return    返回分页查询的结果,是一个Map对象,该对象包含<blockquote>
    157      *        <b>data</b>:查询结果的数据集合是一个List对象<br>
    158      *         <b>pageIndex</b>:当前查询的页数<br>
    159      *         <b>pageSize</b>:每页显示的数据条数<br>
    160      *         <b>total</b>:数据的总条数<br>
    161      *         <b>pageTotal</b>:数据的总页数<br>
    162      *         <b>hasPrev</b>:是否有上一条数据<br>
    163      *         <b>hasNext</b>:是否有下一条数据<br>
    164      *         </blockquote>
    165      * @procedure 拼接HQL语句
    166      * @see IBaseDao
    167      */
    168     Map<String, Object> find(DetachedCriteria detachedCriteria, int pageIndex, int pageSize);
    169     
    170     
    171     
    172 }


    b.IBaseDao接口实现类 -- BaseDao

      1 package com.Elastic.SpringDemo2.ivy.dao;
      2 
      3 import java.io.Serializable;
      4 import java.lang.reflect.ParameterizedType;
      5 import java.util.HashMap;
      6 import java.util.List;
      7 import java.util.Map;
      8 
      9 import org.hibernate.Criteria;
     10 import org.hibernate.Query;
     11 import org.hibernate.Session;
     12 import org.hibernate.criterion.DetachedCriteria;
     13 import org.hibernate.criterion.Projections;
     14 
     15 import com.Elastic.SpringDemo2.ivy.util.HibernateUtil;
     16 //忽略警告
     17 @SuppressWarnings({ "rawtypes", "unchecked" })
     18 public class BaseDao<T> implements IBaseDao<T>{
     19     
     20     private Class entityClass;
     21     
     22     public BaseDao(){
     23         entityClass = this.getEntityClass();
     24     }
     25     
     26     /**
     27      *
     28      * <p>
     29      * <h3>方法功能描述:根据反射得到当前泛型参数(实体类)的数据类型</h3>
     30      * </p>
     31      * @return
     32      * @procedure 执行过程
     33      * @see BaseDao
     34      */
     35     private Class getEntityClass(){
     36         try {
     37             ParameterizedType paramsType = (ParameterizedType)this.getClass().getGenericSuperclass();//只能通过父类得到
     38             return (Class)paramsType.getActualTypeArguments()[0];
     39         } catch (Exception e) {
     40             e.printStackTrace();
     41         }
     42         return null;
     43     }
     44     
     45     @Override
     46     public Session getSession() {
     47         return HibernateUtil.getSession();
     48     }
     49 
     50     private Map<String, Object> createPageData(List<T> data, int pageIndex, int pageSize, int total) {
     51         Map<String, Object>  map = new HashMap<String, Object>();
     52         
     53         //获得总页数
     54         int pageTotal = (int)Math.ceil((double)total / pageSize);
     55         map.put("data", data);
     56         map.put("pageIndex", pageIndex);
     57         map.put("pageSize", pageSize);
     58         map.put("total", total);
     59         map.put("pageTotal", pageTotal);
     60         
     61         //boolean,若没赋值,默认true
     62         map.put("hasPrev", pageIndex > 1);
     63         map.put("hasNext", pageIndex < pageTotal);
     64         return map;
     65     }
     66 
     67     /* (non-Javadoc)
     68      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#save(java.lang.Object)
     69      */
     70     @Override
     71     public void save(T record) {
     72         this.getSession().save(record);
     73         
     74     }
     75 
     76     /* (non-Javadoc)
     77      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#delete(java.io.Serializable)
     78      */
     79     @Override
     80     public void delete(Serializable id) {
     81         this.getSession().delete(this.findById(id));
     82         
     83     }
     84 
     85     /* (non-Javadoc)
     86      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#delete(java.lang.Object)
     87      */
     88     @Override
     89     public void delete(T record) {
     90         this.getSession().delete(record);
     91         
     92     }
     93 
     94     /* (non-Javadoc)
     95      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#update(java.lang.Object)
     96      */
     97     @Override
     98     public void update(T record) {
     99         this.getSession().update(record);
    100         
    101     }
    102 
    103     /* (non-Javadoc)
    104      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#findById(java.io.Serializable)
    105      */
    106     @Override
    107     public T findById(Serializable id) {
    108         return (T) this.getSession().get(entityClass, id);
    109     }
    110 
    111     /* (non-Javadoc)
    112      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(java.lang.String, java.util.Map)
    113      */
    114     @Override
    115     public List<T> find(String hql, Map<String, Object> params) {
    116         Query query = this.getSession().createQuery(hql);
    117         query.setProperties(params);
    118         return query.list();
    119     }
    120 
    121     /* (non-Javadoc)
    122      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(java.lang.String, int, int, java.util.Map)
    123      */
    124     @Override
    125     public Map<String, Object> find(String hql, int pageIndex, int pageSize, Map<String, Object> params) {
    126         String hqlCount;
    127         //通过给定的HQL语句查询全部条数
    128         int i = hql.indexOf("from");
    129         if (i == 0) {
    130             hqlCount = "select count(*) " + hql;
    131         } else {
    132             hqlCount = "select count(*) " + hql.substring(i);
    133         }
    134         
    135         Query query = this.getSession().createQuery(hql);
    136         query.setProperties(params);
    137         
    138         //index从0开始
    139         query.setFirstResult((pageIndex - 1) * pageSize);
    140         query.setMaxResults(pageSize);
    141         
    142         int total = Integer.parseInt(this.getSession().createQuery(hqlCount).uniqueResult().toString());
    143         return this.createPageData(query.list(), pageIndex, pageSize, total);
    144     }
    145 
    146     /* (non-Javadoc)
    147      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(int, int)
    148      */
    149     @Override
    150     public Map<String, Object> find(int pageIndex, int pageSize) {
    151         Criteria criteria = this.getSession().createCriteria(entityClass);
    152         
    153         //查询总数
    154         criteria.setProjection(Projections.rowCount());
    155         int total = Integer.parseInt(criteria.uniqueResult().toString());
    156         criteria.setProjection(null);
    157         
    158         criteria.setFirstResult((pageIndex - 1) * pageSize);
    159         criteria.setMaxResults(pageSize);
    160         return this.createPageData(criteria.list(), pageIndex, pageSize, total);
    161     }
    162 
    163     /* (non-Javadoc)
    164      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(org.hibernate.criterion.DetachedCriteria)
    165      */
    166     public List<T> find(DetachedCriteria detachedCriteria) {
    167         return  detachedCriteria.getExecutableCriteria(getSession()).list();
    168     }
    169 
    170     /* (non-Javadoc)
    171      * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(org.hibernate.criterion.DetachedCriteria, int, int)
    172      */
    173     @Override
    174     public Map<String, Object> find(DetachedCriteria detachedCriteria, int pageIndex, int pageSize) {
    175         //查询总数
    176         int total = Integer.parseInt(detachedCriteria.getExecutableCriteria(getSession())
    177                 .setProjection(Projections.rowCount())
    178                 .uniqueResult().toString());
    179         
    180         //分页查询
    181         Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
    182         criteria.setFirstResult((pageIndex - 1) * pageSize);
    183         criteria.setMaxResults(pageSize);
    184         return this.createPageData(criteria.list(), pageIndex, pageSize, total);
    185     }    
    186 }


    c.具体业务接口 -- UserDao类

    1 package com.Elastic.SpringDemo2.ivy.dao;
    2 
    3 import com.Elastic.SpringDemo2.ivy.entity.User;
    4 
    5 public interface UserDao extends IBaseDao<User> {
    6 
    7 }


    5.service包
    a.业务接口 -- UserService

    1 package com.Elastic.SpringDemo2.ivy.service;
    2 
    3 import com.Elastic.SpringDemo2.ivy.entity.User;
    4 
    5 public interface UserService {
    6     User login(String name, String pass);
    7 }


    6.dao.impl包
    a.接口实现类 -- UserDaoImpl

     1 package com.Elastic.SpringDemo2.ivy.dao.impl;
     2 
     3 import java.io.Serializable;
     4 import java.util.List;
     5 import java.util.Map;
     6 
     7 import org.hibernate.Session;
     8 import org.hibernate.criterion.DetachedCriteria;
     9 
    10 import com.Elastic.SpringDemo2.ivy.dao.BaseDao;
    11 import com.Elastic.SpringDemo2.ivy.dao.UserDao;
    12 import com.Elastic.SpringDemo2.ivy.entity.User;
    13 
    14 public class UserDaoImpl extends BaseDao<User> implements UserDao {
    15 
    16 }


    7.service.impl包
    a.接口实现类 -- UserServiceImpl

     1 package com.Elastic.SpringDemo2.ivy.dao.impl;
     2 
     3 import com.Elastic.SpringDemo2.ivy.dao.UserDao;
     4 import com.Elastic.SpringDemo2.ivy.entity.User;
     5 import com.Elastic.SpringDemo2.ivy.service.UserService;
     6 
     7 public class UserServiceImpl implements UserService {
     8 
     9     private UserDao userDao;
    10 
    11     public UserDao getUserDao() {
    12         return userDao;
    13     }
    14 
    15     public void setUserDao(UserDao userDao) {
    16         this.userDao = userDao;
    17     }
    18 
    19     @Override
    20     public User login(String name, String pass) {
    21         User user = userDao.findById(name);
    22         if (null != user && user.getLoginPass().equals(pass)) {
    23             return user;
    24         }
    25         return null;
    26     }
    27 }


    b.异常抛出增强,接口实现类 -- UserServiceImpl

     1 package com.Elastic.SpringDemo2.ivy.dao.impl;
     2 
     3 import com.Elastic.SpringDemo2.ivy.dao.UserDao;
     4 import com.Elastic.SpringDemo2.ivy.entity.User;
     5 import com.Elastic.SpringDemo2.ivy.service.UserService;
     6 
     7 public class UserServiceImpl implements UserService {
     8 
     9     private UserDao userDao;
    10 
    11     public UserDao getUserDao() {
    12         return userDao;
    13     }
    14 
    15     public void setUserDao(UserDao userDao) {
    16         this.userDao = userDao;
    17     }
    18 
    19     @Override
    20     public User login(String name, String pass) {
    21         User user = userDao.findById(name);
    22         if (user.getLoginPass().equals(pass)) {
    23             return user;
    24         }
    25         return null;
    26     }
    27 }


    8.spring配置文件
    a.后置增强 -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     
    20     <!-- 使用切面 -->
    21     <aop:config>
    22         <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
    23         <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
    24         <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
    25     </aop:config>
    26     
    27 </beans>


    b.后置增强 -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    20     
    21     <!-- 使用切面 -->
    22     <aop:config>
    23         <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
    24         <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
    25         <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
    26         
    27         <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
    28     </aop:config>
    29     
    30 </beans>


    c.异常抛出增强 -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    20     <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    21     
    22     
    23     <!-- 使用切面 -->
    24     <aop:config>
    25         <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
    26         <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
    27         <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
    28         <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
    29         <aop:advisor advice-ref="loggerException" pointcut-ref="pointcut"/>
    30     </aop:config>
    31     
    32 </beans>


    d.环绕增强 -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    20     <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    21     <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    22     
    23     
    24     <!-- 使用切面 -->
    25     <aop:config>
    26         <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
    27         <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
    28         <!-- 环绕增强有顺序 -->
    29         <aop:advisor advice-ref="loggerArround" pointcut-ref="pointcut"/>
    30         <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
    31         <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
    32         <aop:advisor advice-ref="loggerException" pointcut-ref="pointcut"/>
    33         
    34     </aop:config>
    35     
    36 </beans>


    e.使用注解 -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    20     <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    21     <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    22     
    23     <!-- 使用注解 -->
    24     <bean id="loggerAop" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAOP"></bean>
    25     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    26     
    27 </beans>


    f.使用schema -- applicationContext.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:aop="http://www.springframework.org/schema/aop"
     5     xsi:schemaLocation="http://www.springframework.org/schema/beans
     6          http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
     7         http://www.springframework.org/schema/aop
     8         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
     9 
    10     <!-- 使用IoC完成依赖注入 -->
    11     <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>
    12 
    13     <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
    14         <property name="userDao" ref="userDao"></property>
    15     </bean>
    16     
    17     <!-- 织入切面(方法执行前的操作) -->
    18     <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    19     <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    20     <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    21     <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    22     
    23     
    24     <!-- 使用切面 -->
    25     <aop:config>
    26         <!-- 使用schema -->
    27         <aop:aspect ref="loggerAop">
    28             <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
    29             <aop:before method="before" pointcut-ref="pointcut"/>
    30             <aop:after-returning method="after" pointcut-ref="pointcut" returning="returnValue"/>
    31         </aop:aspect>
    32     </aop:config>
    33     
    34     <!-- 使用注解 -->
    35     <bean id="loggerAop" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAOP"></bean>
    36     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    37     
    38 </beans>


    9.aop包
    a.前置增强 -- LoggerBefore类

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import org.springframework.aop.MethodBeforeAdvice;
     6 
     7 public class LoggerBefore implements MethodBeforeAdvice{
     8 
     9     @Override
    10     public void before(Method method, Object[] arg, Object target)
    11             throws Throwable {
    12         System.out.println("执行" + method.getName() + "之前:......");
    13     }
    14 }


    b.后置增强

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import org.springframework.aop.AfterReturningAdvice;
     6 
     7 public class LoggerAfter implements AfterReturningAdvice{
     8 
     9     @Override
    10     public void afterReturning(Object returnValue, Method method, Object[] args,
    11             Object target) throws Throwable {
    12         System.out.println("方法返回值是:" + returnValue);
    13         
    14     }
    15 }


    c.异常抛出增强

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import org.springframework.aop.ThrowsAdvice;
     6 
     7 public class LoggerException implements ThrowsAdvice {
     8     public void afterThrowing(Method method, Object[] args, Object target, Throwable e) {
     9         System.out.println("方法" + method.getName() + "调用时出现异常");
    10     }
    11 }


    d.环绕增强

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import org.aopalliance.intercept.MethodInterceptor;
     6 import org.aopalliance.intercept.MethodInvocation;
     7 
     8 public class LoggerArround implements MethodInterceptor{
     9 
    10     @Override
    11     public Object invoke(MethodInvocation invocation) throws Throwable {
    12         System.out.println("方法执行前");
    13         Object result = invocation.proceed();
    14         System.out.println("方法执行后");
    15         return result;
    16     }
    17 }


    e.注解

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import org.aspectj.lang.JoinPoint;
     4 import org.aspectj.lang.annotation.AfterReturning;
     5 import org.aspectj.lang.annotation.Aspect;
     6 import org.aspectj.lang.annotation.Before;
     7 
     8 @Aspect(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
     9 public class LoggerAOP {
    10     
    11     //value 必填
    12     @Before(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
    13     public void before(JoinPoint point) {
    14         System.out.println(point.getThis());
    15         System.out.println(point.getArgs());
    16         System.out.println(point.getTarget());
    17 
    18    //快照:副本
    19         System.out.println(point.getSignature().getName());
    20         System.out.println("使用注解完成方法执行之前的拦截");
    21     }
    22     
    23     @AfterReturning(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))",returning="returnValue")
    24     //returning的值与参数的值一样
    25     public void after(JoinPoint point, Object returnValue) {
    26         System.out.println("方法执行之后......");
    27         System.out.println(point.getSignature());
    28         System.out.println(returnValue);
    29     }
    30 }


    f.schema

     1 package com.Elastic.SpringDemo2.ivy.aop;
     2 
     3 import org.aspectj.lang.JoinPoint;
     4 import org.aspectj.lang.annotation.AfterReturning;
     5 import org.aspectj.lang.annotation.Aspect;
     6 import org.aspectj.lang.annotation.Before;
     7 
     8 //@Aspect(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
     9 public class LoggerAOP {
    10     
    11     //value 必填
    12 //    @Before(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
    13     public void before(JoinPoint point) {
    14         System.out.println(point.getThis());
    15         System.out.println(point.getArgs());
    16         System.out.println(point.getTarget());
    17         System.out.println(point.getSignature().getName());
    18         System.out.println("使用注解完成方法执行之前的拦截");
    19     }
    20     
    21 //    @AfterReturning(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))",returning="returnValue")
    22     //returning的值与参数的值一样
    23     public void after(JoinPoint point, Object returnValue) {
    24         System.out.println("方法执行之后......");
    25         System.out.println(point.getSignature());
    26         System.out.println(returnValue);
    27     }
    28 }


    10.test包
    a.前置增强 -- Test包

     1 package com.Elastic.SpringDemo2.ivy.test;
     2 
     3 import org.springframework.context.ApplicationContext;
     4 import org.springframework.context.support.ClassPathXmlApplicationContext;
     5 
     6 import com.Elastic.SpringDemo2.ivy.entity.User;
     7 import com.Elastic.SpringDemo2.ivy.service.UserService;
     8 
     9 public class Test {
    10 
    11     public static void main(String[] args) {
    12         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    13         UserService userService = (UserService)context.getBean("userService");
    14         User user = userService.login("admin", "123456");
    15         if (null == user) {
    16             System.out.println("登录失败");
    17         } else {
    18             System.out.println("登录成功");
    19         }
    20     }
    21 }

    b.异常抛出增强 -- Test类

     1 package com.Elastic.SpringDemo2.ivy.test;
     2 
     3 import org.springframework.context.ApplicationContext;
     4 import org.springframework.context.support.ClassPathXmlApplicationContext;
     5 
     6 import com.Elastic.SpringDemo2.ivy.entity.User;
     7 import com.Elastic.SpringDemo2.ivy.service.UserService;
     8 
     9 public class Test {
    10 
    11     public static void main(String[] args) {
    12         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    13         UserService userService = (UserService)context.getBean("userService");
    14         User user = userService.login("admin11111", "123456");
    15         if (null == user) {
    16             System.out.println("登录失败");
    17         } else {
    18             System.out.println("登录成功");
    19         }
    20     }
    21 }

           
    使用注解定义增强:
        1.AspectJ(静态代理)是一个面向切面的框架,它扩展了Java语言,定义了AOP 语法,能够在编译期提供代码的织入
        2.@AspectJ是AspectJ 5新增的功能,使用JDK 5.0 注解技术和正规的AspectJ切点表达式语言描述切面
        3.Spring通过集成AspectJ实现了以注解的方式定义增强类,大大减少了配置文件中的工作量
            a.使用@AspectJ,首先要保证所用的JDK 是5.0或以上版本
            b.将Spring的asm 模块添加到类路径中,以处理@AspectJ中所描述的方法参数名
        
        4.使用注解定义前置增强和后置增强实现日志功能
        5.常用注解有@Aspect、@Before、@AfterReturning、@Around、@AfterThrowing、@After等
        6.通过在配置文件中添加<aop:aspectj-autoproxy />元素,就可以启用对于@AspectJ注解的支持

        7.定义最终增强
            @AspectJ还提供了一种最终增强类型,无论方法抛出异常还是正常退出,该增强都会得到执行,类似于异常处理机制中finally块的作用,一般用于释放资源

    使用Schema配置切面    
        POJO的方法配置成切面,所用标签包括<aop:aspect>、<aop:before>、<aop:after-returning>、<aop:around>、<aop:after-throwing>、<aop:after>等

    Spring AOP and AspectJ AOP 有什么区别?

    • AspectJ 静态代理(AOP框架在编译期生成AOP代理类)。在编译阶段将AspectJ(切面)织入到java字节码中,运行时就是增强的AOP对象。
    • Spring AOP 动态代理。AOP框架不会修改字节码,每次运行时在内存中临时生成一个AOP对象,这个AOP对象包含目标对象的全部方法,在特定的切点做了增强处理,并回调原对象方法。
  • 相关阅读:
    FASM学习中的一些表格
    Win32汇编学习(7):鼠标输入消息
    Win32汇编学习(6):键盘输入消息
    Win32汇编学习(5):绘制文本2
    Win32汇编学习(4):绘制文本
    Win32汇编学习(3):简单的窗口
    怎样建立你自己的MASM导入库
    win32 汇编学习(2):消息框
    Win32汇编学习(1):基本概念
    win32汇编(ASM)学习资源
  • 原文地址:https://www.cnblogs.com/ivy-xu/p/5645540.html
Copyright © 2011-2022 走看看