AOP-基本概念以及底层原理（JDK动态代理实现）

1.什么是AOP

　　1.面向切面编程（面向方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率

　　2.通俗描述：不通过修改源代码方式，在主干功能里添加新功能

AOP（底层原理）

1.AOP底层使用到了动态代理

　　1.两种情况动态代理

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

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

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

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

AOP（JDK动态代理）

1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象

　　调用newProxyInstance方法

方法有三个参数：

　　第一参数：类加载器

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

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

AOP（术语）

1.连接点

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

2.切入点

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

3.通知（增强）

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

　　通知有多种类型

　　　　前置通知

　　　　后置通知

　　　　环绕通知

　　　　异常通知

　　　　最终通知 finally　

4.切面

　　是动作

　　　　把通知应用到切入点过程

AOP操作（准备）

1.Spring框架一般都是基于AspectJ实现AOP操作

　　什么是AspectJ

　　　　AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用进行AOP操作

2.基于AspectJ实现AOP操作

　　1.基于xml配置文件

　　2.基于注解方式实现（使用）

3.在项目工程里面引入AOP相关依赖

        <!-- AOP相关Jar -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
        <dependency>
            <groupId>net.sourceforge.cglib</groupId>
            <artifactId>com.springsource.net.sf.cglib</artifactId>
            <version>2.2.0</version>
        </dependency>

4.切入点表达式

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

　　2.语法结构

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

AOP操作（Aspect注解）

　　1.创建类，在类里面定义方法

public class User {
    public void add(){
        System.out.println("add.... ");
    }
}

　　2.创建增强类（编写增强逻辑）

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

//增强类
public class UserProxy {

    //前置通知
    public void before(){
        System.out.println("before......");
    }
}

　　3.进行通知的配置

　　　　在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.atguigu"/>

</beans>

　　　　使用注解创建User和UserProxy对象

　　　　在增强类上面添加注解@Aspect

　　　　在spring配置文件中国开启生成代理对象

　　配置不同类型的通知

　　　　在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置（五种通知类型注解）

//增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before() {
        System.out.println("before......");
    }
    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning......");
    }
    //最终通知
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterthrowing(){
        System.out.println("afterthrowing...");
    }
    //环绕通知
    @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后");
    }
}

　　相同的切入点抽取

    //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdedmo(){

    }

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointdedmo()")
    public void before() {
        System.out.println("before......");
    }

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

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

@Component//
@Aspect//生成代理
@Order(1)//增强类优先级
public class PersonProxy {

　　完全使用注解开发

　　　　创建配置类，不需要创建xml配置文件

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})//开启组件扫描（开启注解扫描）
@EnableAspectJAutoProxy(proxyTargetClass = true)//生成代理对象（开启Aspect生成代理对象）
public class ConfigAop {

}

AOP操作（Aspect配置文件）

1.创建两个类，增强类和被增强类，创建方法

2.在spring配置文件中创建两个类对象

    <!-- 创建对象 -->
    <bean id="book" class="com.atguigu.spring5.aopxml.Book"/>
    <bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"/>

3.在spring配置文件中配置切入点

    <!-- 配置aop增强 -->
    <aop:config>
        <!-- 切入点
            id:随意起
            expression:切入点
         -->
        <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>

        <!-- 配置切面 -->
        <aop:aspect ref="bookProxy">
            <!-- 增强作用在具体的方法上 -->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>  
    </aop:config>

JdbcTemplate模板

什么是JdbcTemplate

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

准备工作：

　　引入相关jar包

        <!-- JdbcTemplate依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>

　　在spring配置文件配置数据库连接池

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.atguigu"/>

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 配置连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.connectionURL}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

　　配置JdbcTemplate对象，注入DataSource

    <!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

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

　　　　配置文件中开启组件扫描

service层

@Service//注入bean
public class BookService {

    //注入dao
    @Autowired
    public BookDao bookDao;

    //添加方法
    public void addBook(User user){
        bookDao.add(user);
    }

    //修改的方法
    public void updateUser(User user){
        bookDao.updateUser(user);
    }


    //删除的方法
    public void deleteUser(Integer id){
        bookDao.delete(id);
    }

    //查询表记录数
    public int findCount(){
      return bookDao.selectCount();
    }

    //查询返回对象
    public User findOne(Integer id){
        return bookDao.findUserInfo(id);
    }

    //查询返回集合
    public List<User> findAll(){
        return bookDao.findAllUser();
    }

    //批量添加
    public void batchaAdd(List<Object[]> batchArgs){
        bookDao.batchAddUser(batchArgs);
    }

    //批量修改
    public void batchUpdate(List<Object[]> batchArgs){
        bookDao.batchUpdateUser(batchArgs);
    }

    //批量删除
    public void batchDeleteUser(List<Object[]> batchArgs){
        bookDao.batchDeleteUser(batchArgs);
    }
}

dao层

public interface BookDao {

    public void add(User user);

    void updateUser(User user);

    void delete(Integer id);

    int selectCount();

    User findUserInfo(Integer id);

    List<User> findAllUser();

    void batchAddUser(List<Object[]> batchArgs);

    void batchUpdateUser(List<Object[]> batchArgs);

    void batchDeleteUser(List<Object[]> batchArgs);
}

dao层实现类

@Repository//dao层注入bean
public class BookDaoImpl implements BookDao{

    //注入jdbctemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加方法
    @Override
    public void add(User user) {
        //创建sql
        String sql = "insert into t_user values(?,?,?)";
        //调用方法实现添加
        Object[] sx = {user.getUserId(),user.getUsername(),user.getUstatus()};
        int update = jdbcTemplate.update(sql, sx);
        System.out.println(update);
    }

    @Override
    public void updateUser(User user) {
        String sql = "update t_user set username = ?,ustatus = ? where user_id = ? ";
        Object[] sx = {user.getUsername(),user.getUstatus(),user.getUserId()};
        int update = jdbcTemplate.update(sql, sx);
        System.out.println(update);
    }

    @Override
    public void delete(Integer id) {
        String sql = "delete from t_user where user_id = ?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    @Override
    public int selectCount() {
        String sql = "select count(*) from t_user";
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        return integer;
    }

    @Override
    public User findUserInfo(Integer id) {
        String sql = "select * from t_user where user_id = ?";
        //第一个参数：sql 第二个参数：RowMapper是接口，返回不同类型数据，使用这个接口里面实现类完成数据封装 第三个参数：sql语句值
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
        return user;
    }

    @Override
    public List<User> findAllUser() {
        String sql = "select * from t_user";
        List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return userList;
    }

    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql = "insert into t_user values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));


    }

    @Override
    public void batchUpdateUser(List<Object[]> batchArgs) {
        String sql = "update t_user set username = ?,ustatus = ? where user_id = ? ";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    @Override
    public void batchDeleteUser(List<Object[]> batchArgs) {
        String sql = "delete from t_user where user_id = ?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
}

测试类

public class TestUser {


    @Test
    public void testJdbcTemplate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        //添加
//        User user = new User();
//        user.setUserId(1);
//        user.setUsername("mysql");
//        user.setUstatus("b");
//        bookService.addBook(user);


        //修改
//        User user1 = new User();
//        user1.setUserId(1);
//        user1.setUsername("javaupup");
//        user1.setUstatus("atguigu");
//        bookService.updateUser(user1);


        //删除
//        bookService.deleteUser(2);

        //返回总数条数
//        int count = bookService.findCount();
//        System.out.println(count);

        //返回查询对象数据
//        User one = bookService.findOne(1);
//        System.out.println(one);

        //查询返回集合
//        List<User> all = bookService.findAll();
//        System.out.println(all);


        //批量添加
//        ArrayList<Object[]> objects = new ArrayList<>();
//        Object[] o1 = {12,"java","n"};
//        Object[] o2 = {13,"c++","m"};
//        Object[] o3 = {14,"MySQL","p"};
//        objects.add(o1);
//        objects.add(o2);
//        objects.add(o3);
//        //调用批量添加
//        bookService.batchaAdd(objects);

        //批量添加
//        ArrayList<Object[]> objects = new ArrayList<>();
//        Object[] o1 = {"java0909","n3",3};
//        Object[] o2 = {"c++1010","m4",4};
//        Object[] o3 = {"MySQL222","p5",5};
//        objects.add(o1);
//        objects.add(o2);
//        objects.add(o3);
//        //调用批量修改
//        bookService.batchUpdate(objects);

        //批量删除
        ArrayList<Object[]> objects = new ArrayList<>();
        Object[] o1 = {3};
        Object[] o2 = {4};
        Object[] o3 = {5};
        objects.add(o1);
        objects.add(o2);
        objects.add(o3);
        //调用批量修改
        bookService.batchDeleteUser(objects);


    }
}

posted @ 2023-05-22 14:46 monkey大佬阅读(3026) 评论(0) 收藏举报

刷新页面返回顶部

monkey博客