Spring进阶——AOP和动态代理

AOP

Spring-AOP 是对 AOP框架之一。其他比如还有AspectJ
Aspect-Oriented-Programming(面向切面编程)，一种编程思想。

切面：Aspect，由切入点和额外功能（增强）组成。

作用：提供了新的编程角度，不再只是考虑类、对象，而可以考虑切面。切面和目标形成 代理，解决项目业务中额外功 能冗余的问题。

1.为什么用AOP呢？

1.1 业务中的问题

业务层中存在问题：两类逻辑=核心业务+额外功能，其中额外功能存在大量的代码冗余，
：使得项目维护存在极大隐患。

class UserServiceImpl implements UserService{
	private UserDAO ud;
    public void updateUser(User user){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.update(user); //核心功能
    }
    public void inserUser(User user){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.insertUser(user);//核心功能
    }
    public User queryUser(Integer id){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.queryUser(id);//核心功能
    }
}

2. 静态代理

代目标类打理了额外功能**

目标类：UserServiceImpl ,即，被代理的类

代理类原则：要和原始的业务(target)实现同样的接口,保持功能一致。
代理类组成：额外功能(Advice) +目标(Target)

解决了目标类的冗余问题，但自身却依然有冗余！！

示例代码：

class UserServiceProxy implements UserService{//代理类
    UserService us=new UserServiceImpl();
    public void updateUser(User user){
        System.out.println("事务管理功能"); //代理类负责额外功能
        us.updateUser(user); // 目标自己负责核心功能
    }
    public void inserUser(User user){ 
        System.out.println("事务管理功能");//代理类负责额外功能
        us.insertUser(user);// 目标自己负责核心功能
    }
    public User queryUser(Integer id){ 
        System.out.println("事务管理功能");//代理类负责额外功能
        us.queryUser(user);// 目标自己负责核心功能
    }
}```
《----------------------------------------------》
```java
// 创建代理对象，完成业务
UserService userService = new UserServiceProxy();
userService.insertUser(user);

4. AOP 编码流程

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>
<!-- spring-aspects 会传递导入 
     <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
      <scope>compile</scope>
    </dependency>
 	而aspectweaver 即 AspectJ 的一个库,(可以github搜索“AspectJ”，查看在Github上的镜像)。
	spring-AOP模块，并没有独立提供完整的AOP实现，而是集成了【AspectJ框架(AOP框架)】
	spring-aspects就是负责集成AspectJ。
-->
<!-- AOP联盟，可省略，spring4.3.6中的 aop模块中添加了其中的api( 兼容了AOP联盟 )
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>
-->

4.1 准备 Target

public class UserServiceImpl implements UserService{
    private UserDAO userDAO;
    // set/get...
    @Override
    public void updateUser(User user) {
        System.out.println("update in service===============");
        userDAO.updateUser(user);
    }
    @Override
    public void insertUser(User user) {
        System.out.println("insert in service===============");
        userDAO.insertUser(user);
    }
}

4.2 准备 Advice

public class MyBeforeAdvice implements MethodBeforeAdvice{

    /**
     * @param method 当前执行的方法
     * @param args   当前执行的方法中的参数
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before~~~");
    }
}

4.3 编织 Weave

所谓编织，即，将Target 和 Advice 组装 形成代理。
当然组装过程由spring管理，开发者只需要做出配置，告知spring需要组装谁即可

<!-- 声明 Target + Advice -->
<!-- 声明 Target -->
<bean id="userService" class="com.zhj.service.UserServiceImpl">
    <!-- 为userDAO属性赋值，值为id=“userDAO”的组件 -->
    <property name="userDAO" ref="userDAO"/>
</bean>
<!-- Advice -->
<bean id="myBefore" class="com.zhj.advice.MyBeforeAdvice"/>

<!-- 编织 配置 -->
<aop:config>
    <!-- ref="引入MyAdvice" -->
    <aop:aspect ref="myAdvice">
        <!-- 切入点=pointcut
 			execution()表达式：描述切入位置
            组成：修饰符   返回值      包      类  方法名  参数表
                 public Integer com.xx.xxx.AA.xxxXXX(int,String)
            * com.service.UserServiceImpl.*(..)：com.service包下UserServiceImpl类中，返回值修饰符任意，方法名任意，
												 参数表任意
            * com.service.UserServiceImpl.queryUser(..)：同上，只是方法名不是任意，而是 ”queryUser“
		-->
        <aop:pointcut id="pc" expression="execution(* com.service.UserServiceImpl.queryUser(..))"/>
        <aop:advisor advice-ref="myBefore" pointcut-ref="pc"/>
    </aop:aspect>
</aop:config>

4.4 测试

UserService userService = (UserService)context.getBean("userService");
userService.insertUser(new User(...));

4.5 多种Advice

4.5.1 前置额外功能

public class MyBeforeAdvice implements MethodBeforeAdvice{

    /**
     * @param method 当前执行的方法
     * @param args   当前执行的方法中的参数
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before~~~");
    }
}

4.5.2 后置额外功能

public class MyAfterAdvice implements AfterReturningAdvice{

    /**
     *
     * @param returnValue  目标业务方法返回值
     * @param method       当前执行的业务方法对象
     * @param args         方法的参数
     * @param target       目标对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("after~~~");
    }
}

4.5.3 环绕额外功能

public class MyMethodInterceptor implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("begin~~");
        Object ret = invocation.proceed();//执行目标业务方法
        System.out.println("end~~");
        return ret;//返回目标业务方法返回值
    }
}

4.5.4 异常额外功能(了解)

public class MyThrows implements ThrowsAdvice{
    //目标业务方法中抛出异常时，执行此方法。ex=抛出的异常对象
    public void afterThrowing(Exception ex){
        System.out.println(ex.getMessage()+"~~~");
    }
}

4.6 切入点表达式

4.6.1 execution

1> * com.service.UserServiceImpl.queryUser(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：queryUser
    参数表：任意
2> * com.service.UserServiceImpl.*(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
3> * com..UserServiceImpl.*(..)
    修饰符：任意
    返回值：任意
    包:com包，及其子包
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
4> * com.service.*.*(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：所有，任意
    方法：所有，任意
    参数表：任意
5> * *(..)    不建议
    修饰符：任意
    返回值：任意
    包:任意
    类：所有，任意
    方法：所有，任意
    参数表：任意
6> * com.service.UserServiceImpl.query*(..)  【技巧:批量切入】
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
  *注意：尽量精确，避免不必要的切入

4.6.2 within

描述包和类，类中所有方法都切入

within(com.service.UserServiceImpl) 类中的所有方法
within(com..UserServiceImpl) com包和com子包下的类中的所有方法

<aop:pointcut id="pc" expression="within(com..UserServiceImpl)"/>

4.6.3 args

args(int,String,com.entity.User) 参数表如此的方法

<aop:pointcut id="pc" expression="args(int,String,com.entity.User)"/>

4.6.4 联用

不同种类的表达式之间，可以使用逻辑运算：
and or not

<aop:pointcut id="pc" expression="execution(* com.zhj.service.UserServiceImpl.*(..)) and args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) or args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) and not args(com.User)"/>

动态代理

通过动态字节码技术，在运行时动态生成代理（反射）
则既不用维护代理类，又可以有代码打理额外功能

动态代理的实现方案：

• jdk代理（jdk在反射包中提供的一套api）通过和目标实现相同的接口保证功能一致。
• cglib代理（第三方cglib库中的一套api）通过继承目标保证功能一致。

Spring的AOP章节，底层采纳了如上两种代理实现，并对动态代理提供了，简单的，可操作性强的决绝方案。
当项目中需要使用代理解决问题时，可以采用AOP章节的内容加以解决。
org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy()中spring做了jdk代理和cglib代理的选择。

JDK代理

// JDK动态代理

//目标
final UserService us = new UserServiceImpl();
//额外功能
InvocationHandler handler = new InvocationHandler(){
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
        System.out.println("事务开启");
        method.invoke(us, args);
        System.out.println("事务结束");
        return null;
    }
};
//动态组建代理类
UserService proxy = (UserService)Proxy.newProxyInstance(Test.class.getClassLoader(), 
												        us.getClass().getInterfaces(),
												        handler);

CGLib代理

// CGLIB动态代理

//目标
final UserService us = new UserServiceImpl();
//额外功能
MethodInterceptor mi = new MethodInterceptor(){
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) 
        throws Throwable {
        System.out.println("###   before invocation");
        Object result = method.invoke(us, objects);
        System.out.println("###   end invocation");
        return result;
    }
}

Enhancer enhancer = new Enhancer();
// 设置需要代理的对象
enhancer.setSuperclass(us.getClass());
// 设置代理人
enhancer.setCallback(mi);
UserServiceImpl proxy = (UserServiceImpl)enhancer.create();