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类

package com.Elastic.SpringDemo2.ivy.entity;

import java.io.Serializable;

public class User implements Serializable {
    private String loginName;
    private String loginPass;
    
    public String getLoginName() {
        return loginName;
    }
    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }
    public String getLoginPass() {
        return loginPass;
    }
    public void setLoginPass(String loginPass) {
        this.loginPass = loginPass;
    }
    
}

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

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

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.password">root</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernatedb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
 
          <property name="show_sql">true</property>
          <property name="format_sql">true</property>
 
          <mapping resource="com/Elastic/SpringDemo2/ivy/entity/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

3.util包
a.HibernateUtil类

package com.Elastic.SpringDemo2.ivy.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public final class HibernateUtil {
    private static Configuration cfg = null;
    private static SessionFactory sessionFactory = null;
    
    //本地线程
    public static ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
    
    static{
        cfg = new Configuration().configure();
        sessionFactory = cfg.buildSessionFactory();
    }
    
    public static Session getSession(){
        Session session = threadLocal.get();
        if (null == session || !session.isOpen()) {
            session = sessionFactory.openSession();
            threadLocal.set(session);
        }
        return session;
    }
}

4.dao包
a.IBaseDao接口

package com.Elastic.SpringDemo2.ivy.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
public interface IBaseDao<T> {
    /**
     *
     * <p>
     * <h3>方法功能描述：获取Session对象</h3>
     * </p>
     * @return
     * @procedure 执行过程
     * @see IBaseDao
     */
    Session getSession();
    
    /**
     *
     * <p>
     * <h3>方法功能描述：保存数据</h3>
     * </p>
     * @param record    需要保存的对象
     * @procedure 执行过程
     * @see IBaseDao
     */
    void save(T record);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据主键删除对应的数据</h3>
     * </p>
     * @param id
     * @procedure 执行过程
     * @see IBaseDao
     */
    //不明确id的类型，就用Serializable
    void delete(Serializable id);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据数据对象删除数据库中对应的数据</h3>
     * </p>
     * @param record
     * @procedure 执行过程
     * @see IBaseDao
     */
    void delete(T record);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据指定的对象修改对应的数据</h3>
     * </p>
     * @param record
     * @procedure 执行过程
     * @see IBaseDao
     */
    void update(T record);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据主键查询对应的数据</h3>
     * </p>
     * @param id
     * @return 返回查找到的数据，如果没有返回null
     * @procedure 执行过程
     * @see IBaseDao
     */
    T findById(Serializable id);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据指定的hql语句和参数查询语句</h3>
     * </p>
     * @param hql  需要执行的查询的HQL语句
     * @param params  执行的查询的HQL语句所需的参数，如果没有填写null
     * @return    返回查询数据的集合，如果出现异常返回null
     * @procedure 执行过程
     * @see IBaseDao
     */
    List<T> find(String hql,Map<String, Object> params);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据指定的HQL语句和参数以及分页所需的数据执行查询</h3>
     * </p>
     * @param hql   需要执行的查询的HQL语句
     * @param pageIndex    需要查询的页数
     * @param pageSize    每页显示的数据条数
     * @param params    执行的查询的HQL语句所需的参数，如果没有填写null
     * @return    返回分页查询的结果，是一个Map对象，该对象包含<blockquote>
     *        <b>data</b>：查询结果的数据集合是一个List对象<br>
     *         <b>pageIndex</b>：当前查询的页数<br>
     *         <b>pageSize</b>：每页显示的数据条数<br>
     *         <b>total</b>：数据的总条数<br>
     *         <b>pageTotal</b>：数据的总页数<br>
     *         <b>hasPrev</b>：是否有上一条数据<br>
     *         <b>hasNext</b>：是否有下一条数据<br>
     *         </blockquote>
     * @procedure 执行过程
     * @see IBaseDao
     */
    Map<String, Object> find(String hql, int pageIndex, int pageSize, Map<String, Object> params);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：分页查询数据</h3>
     * </p>
     * @param pageIndex    需要查询的页数
     * @param pageSize    每页显示的数据条数
     * @return    返回分页查询的结果，是一个Map对象，该对象包含<blockquote>
     *        <b>data</b>：查询结果的数据集合是一个List对象<br>
     *         <b>pageIndex</b>：当前查询的页数<br>
     *         <b>pageSize</b>：每页显示的数据条数<br>
     *         <b>total</b>：数据的总条数<br>
     *         <b>pageTotal</b>：数据的总页数<br>
     *         <b>hasPrev</b>：是否有上一条数据<br>
     *         <b>hasNext</b>：是否有下一条数据<br>
     *         </blockquote>
     * @procedure 执行过程
     * @see IBaseDao
     */
    Map<String, Object> find(int pageIndex, int pageSize);
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据DetachedCriteria 对象设置的条件查询数据，该功能不具备分页操作</h3>
     * </p>
     * @param detachedCriteria    需要设置的对象查询条件
     * @return    返回查询数据的集合，如果出现异常返回null
     * @procedure 执行过程
     * @see IBaseDao
     */
    List<T> find(DetachedCriteria detachedCriteria);

    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据DetachedCriteria 对象设置的条件进行分页查询</h3>
     * </p>
     * @param detachedCriteria    需要设置的对象查询条件
     * @param pageIndex    需要查询的页数
     * @param pageSize    每页显示的数据条数
     * @return    返回分页查询的结果，是一个Map对象，该对象包含<blockquote>
     *        <b>data</b>：查询结果的数据集合是一个List对象<br>
     *         <b>pageIndex</b>：当前查询的页数<br>
     *         <b>pageSize</b>：每页显示的数据条数<br>
     *         <b>total</b>：数据的总条数<br>
     *         <b>pageTotal</b>：数据的总页数<br>
     *         <b>hasPrev</b>：是否有上一条数据<br>
     *         <b>hasNext</b>：是否有下一条数据<br>
     *         </blockquote>
     * @procedure 拼接HQL语句
     * @see IBaseDao
     */
    Map<String, Object> find(DetachedCriteria detachedCriteria, int pageIndex, int pageSize);
    
    
    
}

b.IBaseDao接口实现类 -- BaseDao

package com.Elastic.SpringDemo2.ivy.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;

import com.Elastic.SpringDemo2.ivy.util.HibernateUtil;
//忽略警告
@SuppressWarnings({ "rawtypes", "unchecked" })
public class BaseDao<T> implements IBaseDao<T>{
    
    private Class entityClass;
    
    public BaseDao(){
        entityClass = this.getEntityClass();
    }
    
    /**
     *
     * <p>
     * <h3>方法功能描述：根据反射得到当前泛型参数（实体类）的数据类型</h3>
     * </p>
     * @return
     * @procedure 执行过程
     * @see BaseDao
     */
    private Class getEntityClass(){
        try {
            ParameterizedType paramsType = (ParameterizedType)this.getClass().getGenericSuperclass();//只能通过父类得到
            return (Class)paramsType.getActualTypeArguments()[0];
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    @Override
    public Session getSession() {
        return HibernateUtil.getSession();
    }

    private Map<String, Object> createPageData(List<T> data, int pageIndex, int pageSize, int total) {
        Map<String, Object>  map = new HashMap<String, Object>();
        
        //获得总页数
        int pageTotal = (int)Math.ceil((double)total / pageSize);
        map.put("data", data);
        map.put("pageIndex", pageIndex);
        map.put("pageSize", pageSize);
        map.put("total", total);
        map.put("pageTotal", pageTotal);
        
        //boolean，若没赋值，默认true
        map.put("hasPrev", pageIndex > 1);
        map.put("hasNext", pageIndex < pageTotal);
        return map;
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#save(java.lang.Object)
     */
    @Override
    public void save(T record) {
        this.getSession().save(record);
        
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#delete(java.io.Serializable)
     */
    @Override
    public void delete(Serializable id) {
        this.getSession().delete(this.findById(id));
        
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#delete(java.lang.Object)
     */
    @Override
    public void delete(T record) {
        this.getSession().delete(record);
        
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#update(java.lang.Object)
     */
    @Override
    public void update(T record) {
        this.getSession().update(record);
        
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#findById(java.io.Serializable)
     */
    @Override
    public T findById(Serializable id) {
        return (T) this.getSession().get(entityClass, id);
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(java.lang.String, java.util.Map)
     */
    @Override
    public List<T> find(String hql, Map<String, Object> params) {
        Query query = this.getSession().createQuery(hql);
        query.setProperties(params);
        return query.list();
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(java.lang.String, int, int, java.util.Map)
     */
    @Override
    public Map<String, Object> find(String hql, int pageIndex, int pageSize, Map<String, Object> params) {
        String hqlCount;
        //通过给定的HQL语句查询全部条数
        int i = hql.indexOf("from");
        if (i == 0) {
            hqlCount = "select count(*) " + hql;
        } else {
            hqlCount = "select count(*) " + hql.substring(i);
        }
        
        Query query = this.getSession().createQuery(hql);
        query.setProperties(params);
        
        //index从0开始
        query.setFirstResult((pageIndex - 1) * pageSize);
        query.setMaxResults(pageSize);
        
        int total = Integer.parseInt(this.getSession().createQuery(hqlCount).uniqueResult().toString());
        return this.createPageData(query.list(), pageIndex, pageSize, total);
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(int, int)
     */
    @Override
    public Map<String, Object> find(int pageIndex, int pageSize) {
        Criteria criteria = this.getSession().createCriteria(entityClass);
        
        //查询总数
        criteria.setProjection(Projections.rowCount());
        int total = Integer.parseInt(criteria.uniqueResult().toString());
        criteria.setProjection(null);
        
        criteria.setFirstResult((pageIndex - 1) * pageSize);
        criteria.setMaxResults(pageSize);
        return this.createPageData(criteria.list(), pageIndex, pageSize, total);
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(org.hibernate.criterion.DetachedCriteria)
     */
    public List<T> find(DetachedCriteria detachedCriteria) {
        return  detachedCriteria.getExecutableCriteria(getSession()).list();
    }

    /* (non-Javadoc)
     * @see com.Elastic.StrutsDemo2.ivy.dao.IBaseDao#find(org.hibernate.criterion.DetachedCriteria, int, int)
     */
    @Override
    public Map<String, Object> find(DetachedCriteria detachedCriteria, int pageIndex, int pageSize) {
        //查询总数
        int total = Integer.parseInt(detachedCriteria.getExecutableCriteria(getSession())
                .setProjection(Projections.rowCount())
                .uniqueResult().toString());
        
        //分页查询
        Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
        criteria.setFirstResult((pageIndex - 1) * pageSize);
        criteria.setMaxResults(pageSize);
        return this.createPageData(criteria.list(), pageIndex, pageSize, total);
    }    
}

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

package com.Elastic.SpringDemo2.ivy.dao;

import com.Elastic.SpringDemo2.ivy.entity.User;

public interface UserDao extends IBaseDao<User> {

}

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

package com.Elastic.SpringDemo2.ivy.service;

import com.Elastic.SpringDemo2.ivy.entity.User;

public interface UserService {
    User login(String name, String pass);
}

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

package com.Elastic.SpringDemo2.ivy.dao.impl;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;

import com.Elastic.SpringDemo2.ivy.dao.BaseDao;
import com.Elastic.SpringDemo2.ivy.dao.UserDao;
import com.Elastic.SpringDemo2.ivy.entity.User;

public class UserDaoImpl extends BaseDao<User> implements UserDao {

}

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

package com.Elastic.SpringDemo2.ivy.dao.impl;

import com.Elastic.SpringDemo2.ivy.dao.UserDao;
import com.Elastic.SpringDemo2.ivy.entity.User;
import com.Elastic.SpringDemo2.ivy.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public User login(String name, String pass) {
        User user = userDao.findById(name);
        if (null != user && user.getLoginPass().equals(pass)) {
            return user;
        }
        return null;
    }
}

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

package com.Elastic.SpringDemo2.ivy.dao.impl;

import com.Elastic.SpringDemo2.ivy.dao.UserDao;
import com.Elastic.SpringDemo2.ivy.entity.User;
import com.Elastic.SpringDemo2.ivy.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public User login(String name, String pass) {
        User user = userDao.findById(name);
        if (user.getLoginPass().equals(pass)) {
            return user;
        }
        return null;
    }
}

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    
    <!-- 使用切面 -->
    <aop:config>
        <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
        <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
        <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
    </aop:config>
    
</beans>

b.后置增强 -- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    
    <!-- 使用切面 -->
    <aop:config>
        <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
        <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
        <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
        
        <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
    </aop:config>
    
</beans>

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    
    
    <!-- 使用切面 -->
    <aop:config>
        <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
        <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
        <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="loggerException" pointcut-ref="pointcut"/>
    </aop:config>
    
</beans>

d.环绕增强 -- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    
    
    <!-- 使用切面 -->
    <aop:config>
        <!-- <aop:pointcut expression="execution(public com.Elastic.SpringDemo2.ivy.entity.User login(java.lang.String, java.lang.String))" id="pointcut"/> -->
        <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
        <!-- 环绕增强有顺序 -->
        <aop:advisor advice-ref="loggerArround" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="loggerBefore" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="loggerAfter" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="loggerException" pointcut-ref="pointcut"/>
        
    </aop:config>
    
</beans>

e.使用注解 -- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    
    <!-- 使用注解 -->
    <bean id="loggerAop" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAOP"></bean>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

f.使用schema -- applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!-- 使用IoC完成依赖注入 -->
    <bean id="userDao" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.Elastic.SpringDemo2.ivy.dao.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 织入切面（方法执行前的操作） -->
    <bean id="loggerBefore" class="com.Elastic.SpringDemo2.ivy.aop.LoggerBefore"></bean>
    <bean id="loggerAfter" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAfter"></bean>
    <bean id="loggerException" class="com.Elastic.SpringDemo2.ivy.aop.LoggerException" ></bean>
    <bean id="loggerArround" class="com.Elastic.SpringDemo2.ivy.aop.LoggerArround" ></bean>
    
    
    <!-- 使用切面 -->
    <aop:config>
        <!-- 使用schema -->
        <aop:aspect ref="loggerAop">
            <aop:pointcut expression="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))" id="pointcut"/>
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after-returning method="after" pointcut-ref="pointcut" returning="returnValue"/>
        </aop:aspect>
    </aop:config>
    
    <!-- 使用注解 -->
    <bean id="loggerAop" class="com.Elastic.SpringDemo2.ivy.aop.LoggerAOP"></bean>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

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

package com.Elastic.SpringDemo2.ivy.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class LoggerBefore implements MethodBeforeAdvice{

    @Override
    public void before(Method method, Object[] arg, Object target)
            throws Throwable {
        System.out.println("执行" + method.getName() + "之前：......");
    }
}

b.后置增强

package com.Elastic.SpringDemo2.ivy.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class LoggerAfter implements AfterReturningAdvice{

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args,
            Object target) throws Throwable {
        System.out.println("方法返回值是：" + returnValue);
        
    }
}

c.异常抛出增强

package com.Elastic.SpringDemo2.ivy.aop;

import java.lang.reflect.Method;

import org.springframework.aop.ThrowsAdvice;

public class LoggerException implements ThrowsAdvice {
    public void afterThrowing(Method method, Object[] args, Object target, Throwable e) {
        System.out.println("方法" + method.getName() + "调用时出现异常");
    }
}

d.环绕增强

package com.Elastic.SpringDemo2.ivy.aop;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class LoggerArround implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("方法执行前");
        Object result = invocation.proceed();
        System.out.println("方法执行后");
        return result;
    }
}

e.注解

package com.Elastic.SpringDemo2.ivy.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
public class LoggerAOP {
    
    //value 必填
    @Before(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
    public void before(JoinPoint point) {
        System.out.println(point.getThis());
        System.out.println(point.getArgs());
        System.out.println(point.getTarget());

　　　//快照：副本
        System.out.println(point.getSignature().getName());
        System.out.println("使用注解完成方法执行之前的拦截");
    }
    
    @AfterReturning(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))",returning="returnValue")
    //returning的值与参数的值一样
    public void after(JoinPoint point, Object returnValue) {
        System.out.println("方法执行之后......");
        System.out.println(point.getSignature());
        System.out.println(returnValue);
    }
}

f.schema

package com.Elastic.SpringDemo2.ivy.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//@Aspect(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
public class LoggerAOP {
    
    //value 必填
//    @Before(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))")
    public void before(JoinPoint point) {
        System.out.println(point.getThis());
        System.out.println(point.getArgs());
        System.out.println(point.getTarget());
        System.out.println(point.getSignature().getName());
        System.out.println("使用注解完成方法执行之前的拦截");
    }
    
//    @AfterReturning(value="execution(* com.Elastic.SpringDemo2.ivy.service..*.*(..))",returning="returnValue")
    //returning的值与参数的值一样
    public void after(JoinPoint point, Object returnValue) {
        System.out.println("方法执行之后......");
        System.out.println(point.getSignature());
        System.out.println(returnValue);
    }
}

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

package com.Elastic.SpringDemo2.ivy.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.Elastic.SpringDemo2.ivy.entity.User;
import com.Elastic.SpringDemo2.ivy.service.UserService;

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)context.getBean("userService");
        User user = userService.login("admin", "123456");
        if (null == user) {
            System.out.println("登录失败");
        } else {
            System.out.println("登录成功");
        }
    }
}

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

package com.Elastic.SpringDemo2.ivy.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.Elastic.SpringDemo2.ivy.entity.User;
import com.Elastic.SpringDemo2.ivy.service.UserService;

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)context.getBean("userService");
        User user = userService.login("admin11111", "123456");
        if (null == user) {
            System.out.println("登录失败");
        } else {
            System.out.println("登录成功");
        }
    }
}

       
使用注解定义增强：
    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对象包含目标对象的全部方法，在特定的切点做了增强处理，并回调原对象方法。