Spring框架4

Spring AOP（面向切面编程）是什么？

   面向切面编程（AOP）和面向对象编程（OOP）类似，也是一种编程模式。Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。
   AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。
   AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。
   目前最流行的 AOP 框架有两个，分别为 Spring AOP 和 AspectJ。
   Spring AOP 使用纯 Java 实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类植入增强的代码。
   AspectJ 是一个基于 Java 语言的 AOP 框架，从 Spring 2.0 开始，Spring AOP 引入了对 AspectJ 的支持。AspectJ 扩展了 Java 语言，提供了一个专门的编译器，在编译时提供横向代码的植入。
   为了更好地理解 AOP，就需要对 AOP 的相关术语有一些了解，这些专业术语主要包含 Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 和 Aspect，它们的含义如下表所示。

名称	说明
Joinpoint（连接点）	指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。
Pointcut（切入点）	指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。
Advice（通知）	指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。
Target（目标）	指代理的目标对象。
Weaving（植入）	指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理）	指生成的代理对象。
Aspect（切面）	切入点和通知的结合。

Spring JDK动态代理

   JDK 动态代理是通过 JDK 中的 java.lang.reflect.Proxy 类实现的。下面通过具体的案例演示 JDK 动态代理的使用。

   1. 创建项目

   2. 创建接口 StudentDao

   在项目的 src 目录下创建一个名为 com.wangxing.jdkproxydemo1.dao的包，在该包下创建一个 StudentDao接口，编辑后如下所示。

package com.wangxing.jdkproxydemo1.dao;


public interface StudentDao {
    public void insertStudent();
    public void updateStudent();
    public void deleteStudent();
    public void selectStudent();
    public void selectOneStudent();
}

   3. 创建实现类 StudentDaoImpl

   在com.wangxing.jdkproxydemo1.dao.impl包下创建 StudentDao接口的实现类 StudentDaoImpl，并实现该接口中的所有方法，如下所示。

package com.wangxing.jdkproxydemo1.dao.impl;

import com.wangxing.jdkproxydemo1.dao.StudentDao;

import java.text.SimpleDateFormat;
import java.util.Date;

public class StudentDaoImpl implements StudentDao {
    @Override
    public void insertStudent() {
        System.out.println("添加学生");
    }

    @Override
    public void updateStudent() {
        System.out.println("修改学生");
    }

    @Override
    public synchronized  void deleteStudent() {
        System.out.println("删除学生");
        try {
            this.wait(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void selectStudent() {
        System.out.println("查询所有学生");
    }

    @Override
    public void selectOneStudent() {
        System.out.println("查询一个学生");
    }
}

   4. 创建切面类 MyAspect

   在 src 目录下，创建一个名为com.wangxing.jdkproxydemo1.jdkaspect的包，在该包下创建一个切面类 MyAspect，编辑后如下所示。

package com.wangxing.jdkproxydemo1.jdkaspect;

import java.text.SimpleDateFormat;
import java.util.Date;

public class MyAspect {
    public void myBefore(){
        System.out.println("方法执行之前");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(new Date());
        System.out.println(format+"开始执行此方法");
    }
    public void myAfter(){
        System.out.println("方法执行之后");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(new Date());
        System.out.println(format+"结束执行此方法");
    }
}

   上述代码中，在切面中定义了两个增强的方法，分别为 myBefore() 方法和 myAfter() 方法，用于对目标类（CustomerDaoImpl）进行增强。

   5. 创建代理类 MyBeanFactory

   在 com.wangxing.jdkproxydemo1.jdkaspect包下创建一个名为 MyBeanFactory 的类，在该类中使用 java.lang.reflect.Proxy 实现 JDK 动态代理，如下所示。

package com.wangxing.jdkproxydemo1.jdkaspect;

import com.wangxing.jdkproxydemo1.dao.StudentDao;
import com.wangxing.jdkproxydemo1.dao.impl.StudentDaoImpl;

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

public class MyBeanFactory {
    public static StudentDao getBean() {
        //准备目标类
        final StudentDao studentDao = new StudentDaoImpl();
        //创建切面类实例
        final MyAspect myAspect = new MyAspect();
        //使用代理类,进行增强
        return (StudentDao) Proxy.newProxyInstance(
                //第一个参数是当前类的类加载器
                MyBeanFactory.class.getClassLoader(),
                //第二参数是所创建实例的实现类的接口
                new Class[]{StudentDao.class},
                //第三个参数就是需要增强的方法
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        myAspect.myBefore();//增强前