spring学习笔记(代理模式和AOP)

代理模式

代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

代理模式中的角色：

1. 抽象主题角色（Subject）：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。
2. 具体主题角色（RealSubject)：也称为委托角色或者被代理角色。定义了代理对象所代表的目标对象。
3. 代理主题角色（Proxy)：也叫委托类、代理类。代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

代理模式又分为静态代理和动态代理。静态代理是由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理是在程序运行时，通过运用反射机制动态的创建而成。

一、静态代理

案例：在对用户增删改查时利用代理对象添加日志输出。

userDao接口：

//用户接口
public interface UserDao {
    void add();
    void del();
    void update();
    void query();
}

userDao接口实现类：

public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("添加了用户");
    }

    @Override
    public void del() {
        System.out.println("删除了用户");
    }

    @Override
    public void update() {
        System.out.println("修改了用户");
    }

    @Override
    public void query() {
        System.out.println("查询用户");
    }
}

代理对象UserDaoProxy：

//代理类，给用户增删改查添加日志
public class UserProxy implements UserDao {

    private UserDaoImpl userDao;

    public UserProxy(UserDaoImpl userDao) {
        this.userDao = userDao;
    }

    public UserProxy() {
    }

    @Override
    public void add() {
        logBefore("添加");
        userDao.add();
        logAfter("添加");
    }

    @Override
    public void del() {
        logBefore("删除");
        userDao.del();
        logAfter("删除");
    }

    @Override
    public void update() {
        logBefore("修改");
        userDao.update();
        logAfter("修改");
    }

    @Override
    public void query() {
        logBefore("查询");
        userDao.query();
        logAfter("查询");
    }

    public void logBefore(String message){
        System.out.println("【日志】:userDao执行"+message+"方法之前。。。");
    }

    public void logAfter(String message){
        System.out.println("【日志】:userDao执行"+message+"方法之后。。。\n");
    }
}

说明：代理对象和被代理对象要实现同一个接口。

测试：

   public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        UserProxy proxy = new UserProxy(userDao);
        proxy.add();
        proxy.del();
        proxy.update();
        proxy.query();

    }

输出结果：

静态代理的缺点：

1. 代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
2. 代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

二、动态代理

动态代理是指在运行时，动态生成代理类。即，代理类的字节码将在运行时生成并载入当前的ClassLoader。与静态代理类想比，动态类有诸多好处。首先，不需要为真是主题写一个形式上完全一样的封装类，假如主题接口中的方法很多，为每一个接口写一个代理方法也是非常烦人的事，如果接口有变动，则真实主题和代理类都要修改，不利于系统维护；其次，使用一些动态代理的生成方法甚至可以在运行时指定代理类的执行逻辑，从而大大提升系统的灵活性。

动态代理实现分为两类：

• 基于接口的动态代理。------JDK动态代理
• 基于类的动态代理。---------cglib

Jdk的动态代理是基于接口的。现在想要为RealSubject这个类创建一个动态代理对象，Jdk主要会做一下工作：

• 获取RealSubject上的所有接口列表
• 确定要生成的代理类的类名
• 根据需要实现的接口信息，在代码中动态创建该Proxy类的字节码
• 将对应的字节码转换为对于的class对象；
• 创建InvocationHandler实例handler,用来处理Proxy所有方法的调用；
• Proxy的class对象以创建的handler对象为参数，实例化一个proxy对象

需要了解两个类：Proxy:代理，InvocationHandler:调用出来程序。

JDK文档：Proxy类

public class Proxy
extends Object
implements SerializableProxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。 
为某个接口创建代理Foo ： 

  InvocationHandler handler = new MyInvocationHandler(...);
     Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
     Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
                     newInstance(handler); 或更简单地： 
  Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class<?>[] { Foo.class },
                                          handler);
动态代理类 （以下简称为代理类 ）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。
代理接口是由代理类实现的接口。 代理实例是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler 。
通过其代理接口之一的代理实例上的方法调用将被分派到实例调用处理程序的invoke方法，传递代理实例， java.lang.reflect.Method被调用方法的java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。
调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在代理实例上调用的结果返回。

newProxyInstance方法：
public static Object newProxyInstance(ClassLoader loader,
                                      类<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。 
Proxy.newProxyInstance因为与IllegalArgumentException相同的原因而Proxy.getProxyClass 。 

参数 
loader - 类加载器来定义代理类 
interfaces - 代理类实现的接口列表 
h - 调度方法调用的调用处理函数 

JDK文档：InvocationHandler接口

public interface InvocationHandlerInvocationHandler是由代理实例的调用处理程序实现的接口 。 
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

Object invoke(Object proxy,
              方法 method,
              Object[] args)
       throws Throwable处理代理实例上的方法调用并返回结果。 当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。 
       
参数 
proxy - 调用该方法的代理实例 
method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。 
args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。 
结果 
从代理实例上的方法调用返回的值。 如果接口方法的声明返回类型是原始类型，则此方法返回的值必须是对应的基本包装类的实例; 否则，它必须是可声明返回类型的类型。 如果此方法返回的值是null和接口方法的返回类型是基本类型，那么NullPointerException将由代理实例的方法调用抛出。 如上所述，如果此方法返回的值，否则不会与接口方法的声明的返回类型兼容，一个ClassCastException将代理实例的方法调用将抛出。 
异常 
Throwable - 从代理实例上的方法调用抛出的异常。 异常类型必须可以分配给接口方法的throws子句中声明的任何异常类型java.lang.RuntimeException检查的异常类型java.lang.RuntimeException或java.lang.Error 。 如果检查的异常是由这种方法是不分配给任何的中声明的异常类型throws接口方法的子句，则一个UndeclaredThrowableException包含有由该方法抛出的异常将通过在方法调用抛出代理实例。

案例：生产者把销售产品交给代理商，代理商收取20%的费用
IProducer接口:

public interface IProducer {
    //销售产品
    public void salleProduce(float money);

    //售后
    public void afterservice(float money);
}

生产者Producer

//生产者
public class Producer implements IProducer {

    //销售产品
    public void salleProduce(float money){
        System.out.println("厂家销售了产品，并拿到了钱："+money);
    }

    //售后
    public void afterservice(float money){
        System.out.println("提供售后服务，并拿到了钱："+money);
    }
}

在客户中创建匿名动态代理类：

package com.wjh.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        IProducer producer = new Producer();


        /**
         * ClassLoader loader:     类加载器，它用于加载代理对象字节码的。和被代理对象使用相同的类加载器
         * Class<?>[] interfaces:  字节码数组，它是用于让代理对象和被代理对象有相同的方法
         * InvocationHandler h):   用于提供增强的代码，写如何代理。通常写匿名内部类。
         */
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(Producer.class.getClassLoader(), Producer.class.getInterfaces(), new InvocationHandler() {
            /**
             *  方法作用：执行被代理对象的任何方法都会经过该方法。
             * @param proxy       代理对象的引用
             * @param method     当前执行的方法
             * @param args       和被代理对象相同的返回值
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object returnValue = null;
                //获取被代理方法的参数
                float money = (float) args[0];
                //判断该方法是不是销售
                if ("salleProduce".equals(method.getName()))
                    returnValue = method.invoke(producer, 0.8f * money);
                return returnValue;
            }
        });

        proxyProducer.salleProduce(10000f);
    }
}

结果：

厂家销售了产品，并拿到了钱：8000.0

JDK动态代理的缺点：被代理类需要实现接口。

spring的AOP

什么是AOP

aop: 面向方面编程 (AOP) 通过提供另一种思考程序结构的方式来补充面向对象编程 (OOP)。OOP 中模块化的关键单位是类，而 AOP 中模块化的单位是方面。方面能够实现跨越多种类型和对象的关注点（例如事务管理）的模块化。（这种关注点在 AOP 文献中通常被称为“横切”关注点。）

aop的作用和优势

作用：
在程序运行期间，不修改源码对已有的方法增强。
优势：

• 减少重复代码
• 提高开发效率
• 维护方便

aop的实现：动态代理技术。

aop的相关术语

• Joinpoint(连接点):
  所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
• Pointcut(切入点):
  所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
• Advice(通知/增强):
  所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
  通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
• Introduction(引介):
  引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
  法或 Field。
• Target(目标对象):
  代理的目标对象。
• Weaving(织入):
  是指把增强应用到目标对象来创建新的代理对象的过程。
• spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
• Proxy（代理）:
  一个类被 AOP 织入增强后，就产生一个结果代理类。
• Aspect(切面):
  是切入点和通知（引介）的结合。

方式一：使用Spring的API接口

一、环境搭建
引入依赖：

<dependencies>
		<!--支持切面-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>

业务类：

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("添加了用户");
    }

    @Override
    public void del() {
        System.out.println("删除了用户");
    }

    @Override
    public void update() {
        System.out.println("修改了用户");
    }

    @Override
    public void query() {
        System.out.println("查询用户");
    }
}

日志前置类：

//日志前置类
public class Log implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"执行了");
    }
}

日志后置类：

//日志后置类
public class AfterLog implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"执行了，返回结果是："+returnValue);
    }
}

spring的配置文件：

<?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.xsd
        http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">

    <bean id="userService" class="com.wjh.dao.impl.UserServiceImpl"></bean>
    <bean id="beforelog" class="com.wjh.Log"></bean>
    <bean id="afterLog" class="com.wjh.AfterLog"></bean>

    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.wjh.dao.impl.UserServiceImpl.*(..))"/>
        
        <aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>
</beans>

方式一：自定义来实现AOP

自定义切面类：

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 用于打印日志，计划让其 在切入点方法执行之前执行
     */
    public void beforePrintLog(){

        System.out.println("logger中的beforePrintLog方法开始记录日志了。。。");
    }
    public void afterReturningPrintLog(){

        System.out.println("logger中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    public void afterThrowingPrintLog(){

        System.out.println("logger中的afterThrowingPrintLog方法开始记录日志了。。。");
    }
    public void afterPrintLog(){

        System.out.println("logger中的afterPrintLog方法开始记录日志了。。。");
    }
}

在配置文件中配置通知：

<?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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>


    <!-- 配置Logger类 -->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
              此标签写在aop:aspect标签内部只能当前切面使用。
              它还可以写在aop:aspect外面，此时就变成了所有切面可用
          -->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置前置通知：在切入点方法执行之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>

            <!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个-->
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>

            <!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>

            <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
             <!-- 配置环绕通知 详细的注释请看Logger类中-->
<!--           <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>-->
        </aop:aspect>
        </aop:aspect>
    </aop:config>

</beans>

测试结果：

Spring 声明式事务控制

Spring 的事务控制可以分为编程式和声明式两种，编程式需要开发者通过编写代码的方式来实现事务管理，并不好用。而声明式则不需要编码，只需开发者按照约定的规则配置即可，实际的事务管理由框架完成，更加方便灵活。接下来就是 Spring 声明式事务控制的使用介绍

业务类：

@Service(value = "userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<User> selectAll() {
        return userDao.selectAll();
    }

    @Override
    public void insertUser(User user) {
        userDao.insertUser(user);
    }

    @Override
    public void delUser(int id) {
        userDao.delUser(id);
    }

    public void Tx(User user,int id){
        userDao.insertUser(user);
        int i = 1/0;
        userDao.delUser(id);
    }
}

spring配置文件：applicationContext.xml

    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--织入事务-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="insertUser"/>
            <tx:method name="delUser"/>
            <tx:method name="selectAll" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--配置切面-->
    <aop:config>
        <aop:pointcut id="txpoint" expression="execution(* com.wjh.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txpoint"/>
    </aop:config>