前言

本文含大量实例，请耐心服用难点是动态代理，这个知识点不会的话可以去看下尚硅谷的java基础这个章节，我听了好几遍很有用~！

三、Aop

3.1 AOP概念

(1）面向切面编程（方面)，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 (2）通俗描述:不通过修改源代码方式，在主干功能里面添加新功能(符合设计模式中的开闭原则，不修改源码，但是能打开扩展功能) (3）使用登录例子说明AOP

3.2 底层原理

1、AOP 底层使用动态代理

（1）有两种情况动态代理

第一种有接口情况，使用 JDK 动态代理

创建接口实现类代理对象，增强类的方法

第二种没有接口情况，使用 CGLIB 动态代理

创建子类的代理对象，增强类的方法

3.3 AOP(JDK)动态代理

方法有三个参数:

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的部分

3.3.1 难点解析

想要实现动态代理，需要解决的问题？

问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象

问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a

1.通过反射提供的API动态的创建一个代理类

2.首先new一个被代理类的对象，传入创建代理类对象的方法中

3.创建代理类的方法中的参数handler其实就抽象化了被代理类要执行的方法

4.handler参数是一个接口，我们创建handler接口的实现类，实例化handler接口的实现类的时候参数为被代理类对象

5.handler接口的实现类重写了handler的invoke方法，

6.invoke方法第二个参数是Method类的method对象，我们通过这个对象可以调用运行时类的方法（运行时类就是我们的加载到内存中的被代理类）

7.之后我们通过method.invoke（obj,args）,第一个obj参数就是被代理类的对象，调用invoke方法时的参数（不知道invoke的可以回顾下反射）

8.这样就可以实现调用代理类对象的invoke方法时，也调用被代理类的方法

9.反射的主要特点就是体会到它的动态性，就是因为我们的代理类没有显示的给它定义出来，而是在运行的时候根据你传入的被代理类的对象是谁

10.我们动态的帮你创建的，体现了反射的动态性

package com.caq.spring5;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class JDKProxy {
    public static void main(String[] args) {
//        创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
//        int add = dao.add(1, 2);
//        System.out.println(add);
        String update = dao.update("3");
        System.out.println(update);
    }
}
class UserDaoProxy implements InvocationHandler{
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法之前执行......"+method.getName()+":传递的参数..."+ Arrays.toString(args));
        Object res = method.invoke(obj, args);
        System.out.println("方法之后执行......"+obj);
        return res;
    }
}

public static void main(String[] args) {
//        创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
//        int add = dao.add(1, 2);
//        System.out.println(add);
        String update = dao.update("3");
        System.out.println(update);
    }
}

3.4 AOP术语

3.4.1 连接点

类里面哪些方法可以被增强,这些方法称为连接点

3.4.2 切入点

实际被真正增强的方法，称为切入点

3.4.3 通知（增强)

(1）实际增强的逻辑部分称为通知（增强)

(2)通知有多钟类型前置通知

后前通知：在要增强方法前执行
后置通知：在要增强方法后执行
环绕通知：在要增强方法前后都执行
异常通知：增强方法发生异常后执行
最终通知：类似与finally，无论发生不发生异常都会执行

3.4.4 切面

是动作（过程）

(1）把通知应用到切入点过程

3.5 AOP操作（准备）

3.5.1 什么是AspectJ？

也是一个框架，一般和Spring一起使用，进行AOP操作

3.5.2 基于AspectJ实现AOP操作

（1）基于xml配置文件实现

（2）基于注解方式实现

3.5.3 在项目工程中引入AOP依赖

3.5.4 切入点表达式

切入点表达式作用就是知道对哪个类里面的方法进行增强

语法结构：

execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

举例：对com.caq.dao.BookDao类里的add进行增强

execution(* com.caq.dao.BookDao.add(...))

==星号代表所有修饰符，返回值类型可以省略不写==

对com.caq.dao.BookDao类里的所有方法进行增强

execution(* com.caq.dao.BookDao.*(...))

对com.caq.dao包里的所有类和方法进行增强

对execution(* com.caq.dao. * . * (...))

3.6 AOP操作(AspectJ注解)

3.6.1 创建类，在类里面定义方法

package com.caq.spring5.aopano;
public class User {    
    public void add(){
        System.out.println("add...");
    }
}

3.6.2 创建增强类（编写增强逻辑）

在增强类里面，创建方法，让不同方法代表不同通知类型

package com.caq.spring5.aopano;
public class UserProxy {
    public void before(){
        System.out.println("before~~~");
    }
}

3.6.3 进行通知的配置

(1)在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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--       开启注释扫描-->
    <context:component-scan base-package="com.caq.spring5.aopano"></context:component-scan>
<!--    就是去扫描你的类，发现有aspect注解的，就生成对应的代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

(2)使用注解创建User和UserProxy对象

其实就是在它们上面加个Compoent就行了

package com.caq.spring5.aopano;
import org.springframework.stereotype.Component;
@Component
public class User {
    public void add(){
        System.out.println("add...");
    }
}

package com.caq.spring5.aopano;
import org.springframework.stereotype.Component;
@Componentpublic 
class UserProxy {
    public void before(){
        System.out.println("before~~~");
    }
}

(3)在增强类上添加注解@Aspect

package com.caq.spring5.aopano;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Component
@Aspect//生产代理对象
public class UserProxy {
    public void before(){
        System.out.println("before~~~");
    }
}

(4)在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:context="http://www.springframework.org/schema/context"       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/context http://www.springframework.org/schema/context/spring-context.xsd                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--       开启注释扫描-->    
    <context:component-scan base-package="com.caq.spring5.aopano">
    </context:component-scan><!--    就是去扫描你的类，发现有aspect注解的，就生成对应的代理对象-->  
      <aop:aspectj-autoproxy>
    </aop:aspectj-autoproxy></beans>

3.7 配置不同类型的通知

package com.caq.spring5.aopano;
import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component@Aspect//生产代理对象
public class UserProxy {    //    beforer注解表示作为前置通知    
    @Before(value = "execution(* com.caq.spring5.aopano.User.add(..))")    
    public void before() {
        System.out.println("before~~~");
    }    //后置通知    
    @AfterReturning(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void afterReturning() {
        System.out.println("AfterReturning~~~");
    }    //最终通知    
    @After(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void after() {
        System.out.println("after~~~");
    }//    异常通知    
    @AfterThrowing(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing~~~");
    }//    环绕通知    
    @Around(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
        System.out.println("环绕之前~~~");//        被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后~~~");
    }
}
环绕之前~~~
    before~~~add...
    环绕之后~~~
    after~~~
    AfterReturning~~~

3.8 公共切入点抽取

package com.caq.spring5.aopano;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Aspect//生产代理对象
@Order(3)
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void pointdemo(){
    }
    //后置通知
    @AfterReturning(value = "pointdemo()")
    public void afterReturning() {
        System.out.println("AfterReturning~~~");
    }
    //最终通知
    @After(value = "pointdemo()")
    public void after() {
        System.out.println("after~~~");
    }
//    异常通知
    @AfterThrowing(value = "pointdemo()")
    public void afterThrowing() {
        System.out.println("afterThrowing~~~");
    }
//    环绕通知
    @Around(value = "pointdemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前~~~");
//        被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后~~~");
    }
}

对相同切入点进行抽取后，如果要修改相同切入点只需要更改公共切入点即可

3.9 多个增强类对同一个方法进行增强设置增强类优先级

3.9.1 @Order（数字类型值）

（1）在增强类上添加注解@Order（数字类型值），数字类型值越小优先级越高

@Component@Aspect//生产代理对象
@Order(3)
public class UserProxy { 
    //    beforer注解表示作为前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before~~~");
    }

@Component@Aspect@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.caq.spring5.aopano.User.add(..))")
    public void afterReturning(){
        System.out.println("Peoson Before..."); 
    }

测试

优先级更大的PersonProxy代理类先执行

Peoson Before...
before~~~

四、JdbcTemplate

4.1 JdbcTemplate(概念和准备)

4.1.1 什么是JdbcTemplate

(1) Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作

4.1.2 准备工作

在原有包的基础上引入新包~

在Spring配置文件配置数据库连接池，配置JdbcTemplate对象，注入DataSource

<?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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    组件扫描-->
    <context:component-scan base-package="com.caq"></context:component-scan>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
<!--    JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--        注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

创建service类，创建dao类，在dao注入jdbctemplate对象

4.2 JdbcTemplate 操作数据库（添加）

4.2.1 Dao层

package com.caq.spring5.dao;
import com.caq.spring5.entity.Book;
public interface BookDao {
    void add(Book book);
}
package com.caq.spring5.entity;
public class Book {
    private String userId;
    private String username;
    private String ustatus;
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getUstatus() {
        return ustatus;
    }
    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

4.2.2 Services层

package com.caq.spring5.service;
import com.caq.spring5.dao.BookDao;
import com.caq.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BookService {
    //    注入dao对象
    @Autowired
    private BookDao bookDao;
//    添加的方法
    public void addBook(Book book){
        bookDao.add(book);
    }
}

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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    组件扫描-->
    <context:component-scan base-package="com.caq"></context:component-scan>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
<!--    JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--        注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

4.2.3 测试

package com.caq.spring5.test;
import com.caq.spring5.entity.Book;
import com.caq.spring5.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testAdd {
    @Test
    public void testJdbcTemplate(){
//        1.解析xml文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//        2.得到对象
        BookService bookService = context.getBean("bookService", BookService.class);
//        3.调用方法
        Book book = new Book();
        book.setUserId("1");
        book.setUsername("php");
        book.setUstatus("running");
        bookService.addBook(book);
    }
}

4.3 JdbcTemplate 操作数据库（修改和删除）

4.3.1 Dao层

package com.caq.spring5.dao;
import com.caq.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class BookDaoImpl implements BookDao {
    //    注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //    添加的方法
    public void add(Book book) {
//        创建sql语句
        String sql = "insert into t_book values(?,?,?)";
//        调用方法实现
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);//0,1,-1
    }
//    修改
    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        Object[] args = {book.getUsername(), book.getUstatus(), book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);//0,1,-1
    }
//    删除
    @Override
    public void deleteBook(String id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);//0,1,-1
    }
}

4.3.2 Services层

package com.caq.spring5.service;
import com.caq.spring5.dao.BookDao;
import com.caq.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BookService {
    //    注入dao对象
    @Autowired
    private BookDao bookDao;
//    添加的方法
    public void addBook(Book book){
        bookDao.add(book);
    }
    public void updateBook(Book book){
        bookDao.updateBook(book);
    }
    public void deleteBook(String id){
        bookDao.deleteBook(id);
    }
}

4.3.3 测试

package com.caq.spring5.test;
import com.caq.spring5.entity.Book;
import com.caq.spring5.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testAdd {
    @Test
    public void testJdbcTemplate(){
//        1.解析xml文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//        2.得到对象
        BookService bookService = context.getBean("bookService", BookService.class);
        //        修改的测试
        Book book = new Book();
        book.setUserId("1");
        book.setUsername("javanb");
        book.setUstatus("Failed");
        bookService.updateBook(book);
        //        删除的测试
        bookService.deleteBook("1");
    }
}

修改后

删除后

4.4 JdbcTemplate 操作数据库（查询返回对象）

下面只放关键代码了，全粘贴上去太浪费时间了

public int findCount(){
        return bookDao.selectCount();
    }
@Override
public int selectCount() {
    String sql = " select count(*) from t_book";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}
int count = bookService.findCount();
        System.out.println(count);
一月 10, 2022 4:22:11 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
2

4.5 JdbcTemplate 操作数据库（查询返回对象）

4.5.1 返回某个对象

//    根据id返回某个对象，类似于查看某个图书的详细信息，其实就是查看这个对象
    public Book findOne(String id){
        return bookDao.findBookInfo(id);
    }
@Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";
//        调用方法
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class),id);
        return book;
    }
    一月 10, 2022 4:39:15 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
Book{userId='1', username='a', ustatus='S'}

4.5.2 返回集合对象

//    查询数据库中所有对象，返回一个集合
    public List<Book> findAll(){
        return bookDao.findAllBook();
    }
        @Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }
    //        查询返回集合
        List<Book> all = bookService.findAll();
        System.out.println(all);
  一月 10, 2022 4:47:21 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
[Book{userId='1', username='a', ustatus='S'}, Book{userId='2', username='b', ustatus='F'}]

4.6 JdbcTemplate 操作数据库（批量操作）

4.6.1 批量添加

//    批量添加
    public void batchAddBook(List<Object[]> batchArgs){
        bookDao.batchAddBook(batchArgs);
    }
     @Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3","C","Success"};
        Object[] o2 = {"4","C++","Success"};
        Object[] o3 = {"5","C#","Success"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
//        调用批量添加
        bookService.batchAddBook(batchArgs);

4.6.2 批量修改

public void batchUpdate(List<Object[]> batchArgs) {
    bookDao.batchUpdate(batchArgs);
}
    @Override
    public void batchUpdate(List<Object[]> batchArgs) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
      List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"Python", "Success", "3"};
        Object[] o2 = {"Object-c", "Success", "4"};
        Object[] o3 = {"Linux", "Success", "5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
//        调用批量添加
        bookService.batchUpdate(batchArgs);
一月 10, 2022 6:50:51 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
[1, 1, 1]

4.6.3 批量删除

//    批量删除
    public void batchDelete(List<Object[]> batchArgs) {
        bookDao.batchDelete(batchArgs);
    }
        @Override
    public void batchDelete(List<Object[]> batchArgs) {
        String sql = "delete from t_book where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
            List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3"};
        Object[] o2 = {"4"};
        Object[] o3 = {"5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
//        调用批量添加
        bookService.batchDelete(batchArgs);
一月 10, 2022 7:00:19 下午 com.alibaba.druid.support.logging.JakartaCommonsLoggingImpl info
信息: {dataSource-1} inited
[1, 1, 1]

Spring--快速入门AOP

前言