1 AOP面向切面编程

1.1 什么是AOP

AOP意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
经典应用：事务管理、性能监视、安全检查、缓存、日志等
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

1.2 AOP实现原理

AOP底层采用代理机制实现
接口+实现类：spring采用jdk动态代理Proxy
实现类：spring采用cglib字节码增强

1.3 AOP术语

AOP示例图

1.target：目标类，需要被代理的类。例如：UserService
2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
3.PointCut 切入点：已经被增强的连接点。例如：addUser()
4.advice 通知/增强，增强代码。例如：after、before
5.Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程
6.proxy 代理类
7.Aspect(切面): 是切入点pointcut和通知advice的结合

2 JDK动态代理

JDK动态代理是对装饰者设计模式的简化，使用前提必须有接口。

2.1 接口和实现类

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("添加");
    }

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

    @Override
    public void deleteUser() {
        System.out.println("删除");
    }
}

2.2 切面类

public class MyAspect {
    public void before(){
        System.out.println("前方法");
    }
    
    public void after(){
        System.out.println("后方法");
    }
}

2.3 代理类

public class MyBeanFactory {
    public static UserService createService(){
        //1.目标类
        final UserService userService = new UserServiceImpl();
        //2.切面类
        final MyAspect myAspect = new MyAspect();
        /* 3.代理类：将目标类（切入点）和切面类（通知）结合，从而形成切面
         *      Proxy.newProxyInstance参数详解：
         *          参数1：loader，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到存储器
         *                  一般情况：当前类.class.getClassLoader();
         *                  目标类实例.getClass().get...
         *          参数2：Class[] interfaces 代理类需要实现的所有接口
         *                  目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
         *          参数3：InvocationHandler是处理类；接口，必须进行实现类，一般采用匿名内部
         *               * 提供了invoke方法，代理类的每一个方法执行，都将调用一次invoke
         *                      参数1：Object proxy ：代理对象
         *                      参数2：Method method : 代理对象当前执行的方法的描述对象（反射）
         *                          执行方法名：method.getName()
         *                          执行方法：method.invoke(对象，实际参数)
         *                      参数3：Object[] args :方法实际参数
         */
        
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(), 
                               userService.getClass().getInterfaces(), 
                               new InvocationHandler() {
                                @Override
                                public Object invoke(Object proxy, Method method, Object[] arg2)
                                        throws Throwable {
                                    //前方法
                                    myAspect.before();
                                    //执行目标类方法
                                    Object obj = method.invoke(userService, arg2);
                                    //后方法
                                    myAspect.after();
                                    return obj;
                                }
                            });
        return proxyInstance;
    }
}

2.4 测试

@org.junit.Test
public void test01(){
    UserService userService = MyBeanFactory.createService();
    userService.addUser();
}

2.5 运行结果

前方法
添加
后方法

3 CGLIB字节码增强

没有接口，只有实现类
采用字节码增强框架cglib，在运行时创建目标类的自雷，从而对目标类进行增强

3.1 创建实现类

public class UserServiceImpl {

    public void addUser() {
        System.out.println("添加");
    }

    public void updateUser() {
        System.out.println("修改");
    }

    public void deleteUser() {
        System.out.println("删除");
    }
}

3.2 代理类

public class MyBeanFactory {
    public static UserServiceImpl createService(){
        // 1.目标类
        final UserServiceImpl userService = new UserServiceImpl();
        // 2.切面类
        final MyAspect myAspect = new MyAspect();
        // 3.代理类，采用cglib，底层创建目标类的子类
        // 3.1  核心类
        Enhancer enhancer = new Enhancer();
        // 3.2 确定父类
        enhancer.setSuperclass(userService.getClass());
        /* 3.3 设置回调函数，MethodInterceptor接口等效 jdk InvocationHandler接口
         *    intercept() 等效 jdk invoke();
         *    参数1、参数2、参数3：以invoke一样
         *    参数4：methodProxy 方法的代理
         */
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] arg2,
                    MethodProxy arg3) throws Throwable {
                //前方法
                myAspect.before();
                //执行目标类方法
                Object obj = method.invoke(userService, arg2);
                //后方法
                myAspect.after();
                return obj;
            }
        });
        // 3.4 创建代理
        UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
        return proxService;
    }
}

3.3 测试类

@org.junit.Test
public void test01(){
     UserServiceImpl userServiceImpl = MyBeanFactory.createService();
     userServiceImpl.addUser();
}

4 AOP联盟通知类型

AOP联盟为通知Advice定义了org.aopalliance.aop.Advice
Spring按照通知Advice在目标类方法的连接点位置，可以分为5类
- 前置通知 org.springframework.aop.MethodBeforeAdvice，在目标方法执行前实施增强
- 后置通知org.springframework.aop.AfterReturningAdvice，在目标方法执行后实施增强
- 环绕通知 org.aopalliance.intercept.MethodInterceptor，在目标方法执行前后实施增强
- 异常抛出通知org.springframework.aop.ThrowsAdvice，在方法抛出异常后实施增强
- 引介通知org.springframework.aop.IntroductionInterceptor，在目标类中添加一些新的方法和属性

5 spring aop半自动代理

让spring 创建代理对象，从spring容器中手动的获取代理对象
所需jar包：4和核心、1个依赖、AOP联盟、spring-aop实现

所需jar包

5.1 接口和实现类

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("添加");
    }

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

    @Override
    public void deleteUser() {
        System.out.println("删除");
    }
}

5.2 切面类

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

/**
 * 切面类中确定通知，需要实现不同接口，接口就是规范，从而就确定方法名称。
 * 采用“环绕通知” MethodInterceptor
 */
public class MyAspect implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("前方法");
        //手动执行目标方法
        Object object = mi.proceed();
        System.out.println("后方法");
        return object;
    }
}

5.3 xml配置

5.4 测试

@org.junit.Test
public void test01(){
    String xmlPath = "spring_aop03/applicationContext.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得代理类
    UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
    userService.addUser();
    }

6 spring aop全自动

从spring容器获得目标类，如果配置aop，spring将自动生成代理
要确定目标类，aspectj 切入点表达式，导入jar包

所需jar包

6.1 xml配置

6.2 测试

@org.junit.Test
public void test01(){
    String xmlPath = "spring_aop04/applicationContext.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得代理类
    UserService userService = (UserService) applicationContext.getBean("userServiceImplId");
    userService.addUser();
}

7 AspectJ

7.1 介绍

AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面，新版本Spring框架，建议使用AspectJ方式来开发AOP

7.2 切入点表达式

execution()用于描述方法
语法：execution(修饰符返回值包.类.方法名(参数) throws异常)
修饰符一般省略

public      公共方法
*           任意

返回值，不能省略

void      返回没有值
String    返回值字符串
*         任意

包，省略

com.itheima.crm             固定包
com.itheima.crm.*.service   crm包下面子包任意 （例如：com.itheima.crm.staff.service）
com.itheima.crm..           crm包下面的所有子包（含自己）
com.itheima.crm.*.service.. crm包下面任意子包，固定目录service，service目录任意包

类，省略

UserServiceImpl         指定类
*Impl                   以Impl结尾
User*                   以User开头
*                       任意

方法名，不能省略

addUser                 固定方法
add*                    以add开头
*Do                     以Do结尾
*                       任意

(参数)

()                          无参
(int)                       一个整型
(int ,int)                  两个
(..)                        参数任意

throws ,可省略，一般不写
示例

综合1
    execution(* com.itheima.crm.*.service..*.*(..))
综合2
    
2.within:匹配包或子包中的方法
    within(com.itheima.aop..*)
3.this:匹配实现接口的代理对象中的方法
    this(com.itheima.aop.user.UserDAO)
4.target:匹配实现接口的目标对象中的方法
    target(com.itheima.aop.user.UserDAO)
5.args:匹配参数格式符合标准的方法
    args(int,int)
6.bean(id)  对指定的bean所有的方法
    bean('userServiceId')

7.3 AspectJ通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称
aspectj 通知类型
- before：前置通知(应用：各种校验)，在方法执行前执行，如果通知抛出异常，阻止方法运行
- afterReturning：后置通知(应用：常规数据处理)，方法正常返回后执行，如果方法中抛出异常，通知无法执行，必须在方法执行后才执行，所以可以获得方法的返回值。
- around：环绕通知(功能强大，应用范围广)，方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法
- afterThrowing：抛出异常通知(应用：包装异常信息)，方法抛出异常后执行，如果方法没有抛出异常，无法执行
- after：最终通知(应用：清理现场)，方法执行完毕后执行，无论方法中是否出现异常

8 AspectJ示例（基于xml）

所需jar包：1.aop联盟规范，2.spring aop实现，3.aspect规范，4.spring aspect实现

所需jar包

8.1 接口和实现类

public interface UserService {
    
    public void addUser();
    public String updateUser();
    public void deleteUser();
}

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("d_aspect.a_xml addUser");
    }

    @Override
    public String updateUser() {
        System.out.println("d_aspect.a_xml updateUser");
        int i = 1/ 0;
        return "hello";
    }

    @Override
    public void deleteUser() {
        System.out.println("d_aspect.a_xml deleteUser");
    }
}

8.2 切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面类，含有多个通知
 */
public class MyAspect {
    
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }
    
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }
    
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();
        
        System.out.println("后");
        return obj;
    }
    
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }
    
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

8.3 xml配置

8.4 测试

@Test
public void demo01(){
    String xmlPath = "com/itheima/d_aspect/a_xml/beans.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得目标类
    UserService userService = (UserService) applicationContext.getBean("userServiceId");
    userService.addUser();
    userService.updateUser();
    userService.deleteUser();
}

9 AspectJ示例（基于注解）

9.1 接口与实现类

public interface UserService {
    
    public void addUser();
    public String updateUser();
    public void deleteUser();
}

@Service("userServiceId")
public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("d_aspect.b_anno addUser");
    }

    @Override
    public String updateUser() {
        System.out.println("d_aspect.b_anno updateUser");
        int i = 1/ 0;
        return "Hello";
    }

    @Override
    public void deleteUser() {
        System.out.println("d_aspect.b_anno deleteUser");
    }
}

9.2 切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {
    
    //切入点当前有效
//  @Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }
    
    //声明公共切入点
    @Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
    private void myPointCut(){
    }
    
//  @AfterReturning(value="myPointCut()" ,returning="ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }
    
//  @Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();
        
        System.out.println("后");
        return obj;
    }
    
//  @AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }
    
    @After("myPointCut()")
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

9.3 xml配置

9.4 测试

@Test
public void demo01(){
    String xmlPath = "com/itheima/d_aspect/b_anno/beans.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得目标类
    UserService userService = (UserService) applicationContext.getBean("userServiceId");
    userService.addUser();
    userService.updateUser();
    userService.deleteUser();
}

10 JdbcTemplate

spring提供了JDBC JdbcTemplate操作数据库，使用前需先导入jdbc和事务的jar包

所需jar包

10.1 API方式操作

创建实体类

public class UserVo {
    public int id;
    public String name;
    public int money;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

编写JdbcTemplate类

import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class JdbcAPI {

    public static void main(String[] args) {
        // 创建数据库连接池
        BasicDataSource dataSource = new BasicDataSource();

        // 加载驱动、链接、用户名、密码
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/study");
        dataSource.setUsername("root");
        dataSource.setPassword("10086");
        
        // 创建JdbcTemplate模板
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        // 数据源注入模板
        jdbcTemplate.setDataSource(dataSource);
        
        // 通过AIP操作数据库
        jdbcTemplate.update("insert into account (name,money) values (?,?)", "jack","1000");
    }
}

10.2 DBCP连接池操作

创建UserDao类

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import cn.lm.entity.UserVo;

public class UserDao {

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    public void update(UserVo user) {
        String sql = "update account set money=?,name=? where id=?";
        jdbcTemplate.update(sql,user.getMoney(),user.getName(),user.getId());
    }
    
    public void findUser(UserVo u) {
        String sql = "select * from account where id=?";
        RowMapper rowMapper = new BeanPropertyRowMapper<>(UserVo.class); 
        UserVo userVo = jdbcTemplate.queryForObject(sql,rowMapper,u.getId());
        System.out.println(userVo.getId()+"..."+userVo.getName()+"..."+userVo.getMoney());
    }
}

xml配置

测试类

public class Test {

    @org.junit.Test
    public void update() {
        UserVo user = new UserVo();
        user.setId(1);
        user.setName("刘能");
        user.setMoney(2000);
        
        String xmlPath = "cn/lm/dbcp/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
        //获得目标类
        UserDao userDao = (UserDao) applicationContext.getBean("userDaoId");
        userDao.update(user);
        //System.out.println(user.getId());
    }
    
    @org.junit.Test
    public void findUser() {
        UserVo user = new UserVo();
        user.setId(1);
        String xmlPath = "cn/lm/dbcp/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
        //获得目标类
        UserDao userDao = (UserDao) applicationContext.getBean("userDaoId");
        userDao.findUser(user);
    }
}

10.3 C3P0连接池操作

UserDao

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import cn.lm.entity.UserVo;

public class UserDao {

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    public List findAll() {
        String sql = "select * from account";
        RowMapper rowMapper = new BeanPropertyRowMapper<>(UserVo.class);
        List list = jdbcTemplate.query(sql, rowMapper);
        return list;
    }
}

xml配置

测试类

@org.junit.Test
public void findAll() {
    UserVo user = new UserVo();
    user.setId(1);
    String xmlPath = "cn/lm/c3p0/applicationContext.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得目标类
    UserDao userDao = (UserDao) applicationContext.getBean("userDaoId");
    List list = userDao.findAll();
    for (UserVo userVo : list) {
        System.out.println(userVo.getId()+"..."+userVo.getName()+"..."+userVo.getMoney());
    }
}

10.4 JdbcDaoSupport

使用模板操作JDBC存在一个缺点，就是每次都要编写模板并注入，spring提供了JdbcTemplate的父类，只需继承JdbcDaoSupport类即可
UserDao

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import cn.lm.entity.UserVo;

public class UserDao extends JdbcDaoSupport{
    
    public List findAll() {
        String sql = "select * from account";
        RowMapper rowMapper = new BeanPropertyRowMapper<>(UserVo.class);
        List list = this.getJdbcTemplate().query(sql, rowMapper);
        return list;
    }
}

xml 配置

测试

@org.junit.Test
public void findAll() {
    UserVo user = new UserVo();
    user.setId(1);
    String xmlPath = "cn/lm/JdbcDaoSupport/applicationContext.xml";
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        
    //获得目标类
    UserDao userDao = (UserDao) applicationContext.getBean("userDaoId");
    List list = userDao.findAll();
    for (UserVo userVo : list) {
        System.out.println(userVo.getId()+"..."+userVo.getName()+"..."+userVo.getMoney());
    }
}

10.4 配置properties文件

properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ee19_spring_day02
jdbc.user=root
jdbc.password=1234

spring框架02

1 AOP面向切面编程

1.1 什么是AOP

1.2 AOP实现原理

1.3 AOP术语

2 JDK动态代理

2.1 接口和实现类

2.2 切面类

2.3 代理类

2.4 测试

2.5 运行结果

3 CGLIB字节码增强

3.1 创建实现类

3.2 代理类

3.3 测试类

4 AOP联盟通知类型

5 spring aop半自动代理

5.1 接口和实现类

5.2 切面类

5.3 xml配置

5.4 测试

6 spring aop全自动

6.1 xml配置

6.2 测试

7 AspectJ

7.1 介绍

7.2 切入点表达式

7.3 AspectJ通知类型

8 AspectJ示例（基于xml）

8.1 接口和实现类

8.2 切面类

8.3 xml配置

8.4 测试

9 AspectJ示例（基于注解）

9.1 接口与实现类

9.2 切面类

9.3 xml配置

9.4 测试

10 JdbcTemplate

10.1 API方式操作

10.2 DBCP连接池操作

10.3 C3P0连接池操作

10.4 JdbcDaoSupport

10.4 配置properties文件

你可能感兴趣的:(spring框架02)