Spring5 基础2IOC 容器 IOC 操作 Bean 管理（基于注解方式）完全注解开发使用注解 @Config

IOC 容器

IOC 操作 Bean 管理（基于注解方式）

完全注解开发

使用注解 @Configuration，创建配置类，替代 xml配置文件，使用注解 @ComponentScan 配置扫描文件
编写测试类，更改配置类 AnnotationConfigApplicationContext

package com.atjava.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author lv
 * @create 2021-12-12 16:30
 */

@Configuration // 添加注解，作为配置类，替代 xml配置文件
@ComponentScan(basePackages = {"com.atjava.spring5"})
public class SpringConfig {
}

package com.atjava.spring5.test;

import com.atjava.spring5.config.SpringConfig;
import com.atjava.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.annotation.Resource;

/**
 * @author lv
 * @create 2021-12-09 23:34
 */
public class TestSpring5 {

    @Test
    public void testSpring2 () {
        /**
         * 加载配置类 AnnotationConfigApplicationContext
         */
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.add();

        /**
         * UserService{name='lv', age=123, userDao=com.atjava.spring5.dao.UserDaoImpl2@a9cd3b1}
         * add userService ...
         * userDaoImpl2 add...
         */
    }
}

AOP：面向切面编程

面向切面编程，利用 AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。
在不修改源代码的情况下，在主干功能里面添加新功能
如登录模块和权限控制模块的分离

AOP：底层原理

AOP 底层使用动态代理

有两种动态代理的情况：

有接口情况，使用 JDK动态代理
- 创建接口实现类的代理对象，增强类的方法
没有接口情况，使用 CGLIB 动态代理
- 创建当前类子类的代理对象，增强类的方法

AOP（JDK动态代理）

JDK动态代理，使用 Proxy类中的方法创建代理对象 java.lang.reflect.Proxy
- newProxyInstance() 返回指定接口的代理类实例
- 参数一：ClassLoader 类加载器
- 参数二：增强方法所在类实现的接口，支持多个接口
- 参数三：实现这个接口 InvocationHandler，创建代理对象，写增强的方法
编写 JDK动态代理代码
1. 创建接口 UserDao，实现类 UserDaoImpl

package com.atjava.spring5.dao;

/**
 * @author lv
 * @create 2021-12-12 18:17
 */
public interface UserDao {
    public int add (int a, int b);
    public String update (String id);
}

package com.atjava.spring5.dao;

/**
 * @author lv
 * @create 2021-12-12 18:18
 */
public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        System.out.println("执行 add方法...");
        return a + b;
    }

    @Override
    public String update(String id) {
        System.out.println("update 方法执行了...");
        return id;
    }
}

使用 Proxy类，创建接口代理对象
- ClassLoader 类加载器，JDKProxy.class.getClassLoader()
- 创建接口实现类代理对象 Class[] ifs
- 创建代理对象 UserDaoProxy

使用 Proxy类

package com.atjava.spring5.proxy;


import com.atjava.spring5.dao.UserDao;
import com.atjava.spring5.dao.UserDaoImpl;
import com.atjava.spring5.invo.UserDaoProxy;

import java.lang.reflect.Proxy;

/**
 * @author lv
 * @create 2021-12-12 18:23
 */
public class JDKProxy {
    public static void main (String[] args) {
        // 创建接口实现类代理对象
        Class[] ifs = {UserDao.class};
        UserDaoProxy udp = new UserDaoProxy(new UserDaoImpl());
//        Object proxyInstance = Proxy.newProxyInstance(
//                JDKProxy.class.getClassLoader(),
//                ifs,
//                /**
//                 * 1.使用匿名实现类
//                 * 2.使用单独实现类
//                 */
//                new InvocationHandler() {
//                    @Override
//                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                        return null;
//                    }
//                }
//        );
        // 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
        UserDao proxyInstance = (UserDao) Proxy.newProxyInstance(
                JDKProxy.class.getClassLoader(),
                ifs,
                /**
                 * 1.使用匿名实现类
                 * 2.使用单独实现类
                 */
                udp
        );
        int add = proxyInstance.add(1, 2);
        System.out.println("result：" + add);

        String update = proxyInstance.update("lv update");
        System.out.println("result：" + update);

        /**
         * 方法执行前...add：方法传递的参数：[1, 2]
         * 执行 add方法...
         * 方法之后执行：com.atjava.spring5.dao.UserDaoImpl@d716361
         * result：3
         * 方法执行前...update：方法传递的参数：[lv update]
         * update 方法执行了...
         * 方法之后执行：com.atjava.spring5.dao.UserDaoImpl@d716361
         * result：lv update
         */
    }

}

创建代理对象 UserDaoProxy

package com.atjava.spring5.invo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author lv
 * @create 2021-12-12 18:35
 */

// 创建代理对象代码
public class UserDaoProxy implements InvocationHandler {

    private Object obj;
    /**
     * 将被代理的对象传递过来，增强它的功能，
     * 通过有参构造的方法将 目标对象传递过来
     */
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }
    // 编写 AOP需要增加的功能
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 被增强的方法之前执行
        System.out.println("方法执行前..." + method.getName() + "：方法传递的参数：" + Arrays.toString(args));

        // 执行被增强的方法
        Object res = null;
        if (method.getName() == "add") {
            res = method.invoke(obj, args);
        } else if (method.getName() == "update") {
            res = method.invoke(obj, args);
        }

        // 被执行的方法之后执行
        System.out.println("方法之后执行：" + obj);
        return res;
    }
}

AOP 术语

连接点：类中可以被增强的方法，那这些方法被称为连接点
切入点：类中实际被真正增强的方法，此方法被被称为切入点
通知（增强）：实际增强的逻辑部分称为通知（增强），比如登录模块中额外添加的权限判断模块就是通知（增强）
通知的类型：
1. 前置通知：在切入点之前执行
2. 后置通知：在切入点后执行
3. 环绕通知：在切入点的前后都有执行
4. 异常通知：在切入点执行时出现异常
5. 最终通知：类似于语法中的 finally，最终一定会执行
切面：是动作，将通知应用到切入点的过程就称为切面，如将权限判断加入到登录方法的过程

AOP 操作（准备）

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

AspectJ：

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

基于 AspectJ 实现 AOP操作：

基于 xml配置文件实现
基于注解方式实现（推荐）

在项目工程中引入 AOP相关依赖：

com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aspects-5.2.6.RELEASE.jar

切入点表达式：

切入点表达式作用：明确对哪个类中的哪个方法进行增强
语法结构：execution( [权限修饰符][返回类型][类全路径][方法名称]([参数列表]) )
某个类中某个方法，举例 1：对 com.atjava.dao.BookDao类中的 add方法进行增强
- execution(* com.atjava.dao.BookDao.add(...)); *表示任意修饰符，返回类型可省略
某个类中所有方法，举例 2：对 com.atjava.dao.BookDao类中的所有方法进行增强
- execution(* com.atjava.dao.BookDao.*(...)); *表示任意修饰符、方法，返回类型可省略
某个包中所有类，类中所有方法，举例 3：对 com.atjava.dao包中所有类，类中所有方法进行增强
- execution(* com.atjava.dao..(...))

AOP 操作（AspectJ 注解方式）

创建类，在类中编写被增强方法
创建增强类（编写增强逻辑）
1. 在增强类中，创建方法，让不同方法代表不同通知类型
进行通知的配置
1. 在 Spring配置文件中，开启注解扫描
2. 使用注解创建 User和 UserProxy对象
3. 在增强类上面添加注解 @Aspect
4. 在 Spring配置文件中开启生成代理对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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"
>

    <!--
        1.在配置文件中开启扫描
    -->
    <context:component-scan base-package="com.atjava.spring5.aopanno" />

    <!--
        4.开启 Aspect 生成代理对象
    -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

package com.atjava.spring5.aopanno;

import org.springframework.stereotype.Component;

/**
 * @author lv
 * @create 2021-12-13 23:23
 */

// 被增强类
@Component
public class User {
    public void add() {
        System.out.println("被增强方法 add...");
    }
}

package com.atjava.spring5.aopanno;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * @author lv
 * @create 2021-12-13 23:25
 */

// 增强类
@Component // 2.创建对象
@Aspect // 3.在增强类上面添加注解 @Aspect
public class UserProxy {

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

}

配置不同类型的通知

在增强类中，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
前置通知： @Before(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
最终通知： @After(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
1. 不管有没有异常都会执行
2. 在方法执行之后执行
后置（返回）通知：@AfterReturning(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
1. 有异常时不会执行
2. 在方法返回值之后执行，与 @After稍有区别
异常通知： @AfterThrowing(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
1. 被增强的方法（切入点）执行时出现异常，会执行此方法
环绕通知：@Around(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
1. 切入点出现异常后，环绕之前会执行，环绕之后不会执行
2. 在切入点执行之前和之后都会执行

package com.atjava.spring5.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author lv
 * @create 2021-12-13 23:25
 */

// 增强类
@Component // 2.创建对象
@Aspect // 3.在增强类上面添加注解 @Aspect
public class UserProxy {

    // 前置通知
    // @Before 注解，作为前置通知
    @Before(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void before() {
        System.out.println("前置通知 before...");
    }

    /**
     * 最终通知：
     * 在方法执行之后执行，不管有没有异常都会执行
     */
    @After(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void after() {
        System.out.println("最终通知 after...");
    }

    /**
     * 后置（返回）通知：
     * 在方法返回值之后执行，与 @After稍有区别，有异常不会执行
     */
    @AfterReturning(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("后置（返回）通知 afterReturning...");
    }

    /**
     * 异常通知：
     * 被增强的方法（切入点）执行时出现异常，会执行此方法
     */
    @AfterThrowing(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("异常通知 afterThrowing...");
    }

    /**
     * 环绕通知：
     * 在切入点之前和之后都会执行
     */
    @Around(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint ProceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前 around...");
        // 被增强的方法执行
        ProceedingJoinPoint.proceed();
        System.out.println("环绕之后 around...");

    }

}

package com.atjava.spring5.test;

import com.atjava.spring5.aopanno.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


/**
 * @author lv
 * @create 2021-12-14 21:45
 */
public class TestAop {

    @Test
    public void testAopAno() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("beanaop.xml");

        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
        /**
         * com.atjava.spring5.aopanno.User@543588e6
         * 前置通知 before...
         * 被增强方法 add...
         */

        /**
         * com.atjava.spring5.aopanno.User@1de76cc7
         * 环绕之前 around...
         * 前置通知 before...
         * 被增强方法 add...
         * 环绕之后 around...
         * 最终通知 after...
         * 后置（返回）通知 afterReturning...
         */

        /** 切入点执行异常：
         * com.atjava.spring5.aopanno.User@1de76cc7
         * 环绕之前 around...
         * 前置通知 before...
         * 最终通知 after...
         * 异常通知 afterThrowing...
         */
    }
}

公共切入点抽取

使用注解 @Pointcut(value = "execution(* com.atjava.spring5.aopanno.User.add(..)))")

package com.atjava.spring5.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author lv
 * @create 2021-12-13 23:25
 */

// 增强类
@Component // 2.创建对象
@Aspect // 3.在增强类上面添加注解 @Aspect
public class UserProxy {

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

    // 前置通知
    // @Before 注解，作为前置通知
    //@Before(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    @Before(value = "pointCut()") // 抽取相同的切入点
    public void before() {
        System.out.println("前置通知 before...");
    }

    /**
     * 最终通知：
     * 在方法执行之后执行，不管有没有异常都会执行
     */
    //@After(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    @After(value = "pointCut()")
    public void after() {
        System.out.println("最终通知 after...");
    }
    
    // ...

}

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

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

package com.atjava.spring5.aopanno;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author lv
 * @create 2021-12-17 22:10
 */
@Component
@Aspect
@Order(2) // 设置增强类优先级
public class PersonProxy {

    @Before(value = "execution(* com.atjava.spring5.aopanno.User.add(..))")
    public void before() {
        System.out.println("PersonProxy before...");
    }
}

package com.atjava.spring5.test;

import com.atjava.spring5.aopanno.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


/**
 * @author lv
 * @create 2021-12-14 21:45
 */
public class TestAop {

    @Test
    public void testAopAno() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("beanaop.xml");

        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();

        /**
         * com.atjava.spring5.aopanno.User@4b0d79fc
         * 环绕之前 around...
         * 前置通知 before...
         * PersonProxy before...
         * 被增强方法 add...
         * 环绕之后 around...
         * 最终通知 after...
         * 后置（返回）通知 afterReturning...
         */
    }
}

完全使用注解开发

创建配置类，无需配置 xml配置文件

package com.atjava.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author lv
 * @create 2021-12-19 21:54
 */
@Configuration // 定义配置类
@ComponentScan(basePackages = {"com.atjava.spring5"}) // 开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) // 开启 Aspect生成代理对象
public class ConfigAop {
}

test 测试：AnnotationConfigApplicationContext(class)

@Test
// 完全注解开发：
public void testAopAno2() {
    ApplicationContext context =
            new AnnotationConfigApplicationContext(ConfigAop.class);
    User user = (User)context.getBean("user");
    System.out.println("User：" + user);
    user.add();

    /**
     * User：com.atjava.spring5.aopanno.User@6cd28fa7
     * 环绕之前 around...
     * 前置通知 before...
     * PersonProxy before...
     * 被增强方法 add...
     * 环绕之后 around...
     * 最终通知 after...
     * 后置（返回）通知 afterReturning...
     */
}

AOP 操作（AspectJ xml配置文件方式）

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

package com.atjava.spring5.aopxml;

/**
 * @author lv
 * @create 2021-12-19 21:08
 */
// 被增强类
public class Book {
    public void buy() {
        System.out.println("Book buy...");
    }
}

package com.atjava.spring5.aopxml;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author lv
 * @create 2021-12-19 21:10
 */
// 增强类
public class BookProxy {
    public void before() {
        System.out.println("before...");
    }
    public void after() {
        System.out.println("after...");
    }
    public void afterReturning() {
        System.out.println("afterReturning...");
    }
    public void afterThrowing() {
        System.out.println("afterThrowing...");
    }
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before proceedingJoinPoint...");
        proceedingJoinPoint.proceed();
        System.out.println("after proceedingJoinPoint...");
    }
}

在 Spring 配置文件中创建两个类对象
在 Spring 配置文件中配置切入点 aop:config

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

    <!--
        2.创建两个类的对象
    -->
    <bean id="book" class="com.atjava.spring5.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.atjava.spring5.aopxml.BookProxy"></bean>

    <!--
        3.配置 AOP 增强
    -->
    <aop:config>
        <!--配置切入点：-->
        <aop:pointcut id="pc" expression="execution(* com.atjava.spring5.aopxml.Book.buy(..))"></aop:pointcut>
        <!--配置切面：-->
        <aop:aspect ref="bookProxy">
            <!--配置增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="pc"></aop:before>
            <aop:after method="after" pointcut-ref="pc"></aop:after>
            <aop:after-returning method="afterReturning" pointcut-ref="pc"></aop:after-returning>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pc"></aop:after-throwing>
            <aop:around method="around" pointcut-ref="pc"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

@Test
public void testAopXml () {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("beanxml.xml");
    Book book = context.getBean("book", Book.class);
    System.out.println("book" + book);
    book.buy();
    /**
     * bookcom.atjava.spring5.aopxml.Book@305b7c14
     * before...
     * before proceedingJoinPoint...
     * Book buy...
     * after proceedingJoinPoint...
     * afterReturning...
     * after...
     */
}

JdbcTemplate

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

准备工作：

引入依赖：

spring-jdbc-5.2.6.RELEASE.jar
spring-orm-5.2.6.RELEASE.jar
spring-orm-5.2.6.RELEASE.jar
mysql-connector-java-5.1.7-bin.jar

在 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"
       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">

    <!-- 2.数据库连接池 -->
    <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>
    
    <!--
        3.创建 JdbcTemplate 对象：
    -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入 dataSource，使用 set方法-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

创建 service类、dao类，在 dao注入 JdbcTemplate对象

开启组件扫描

<!--开启组件扫描-->
<context:component-scan base-package="com.atjava.spring5"></context:component-scan>

创建 service类、dao类，在 dao注入 JdbcTemplate对象

package com.atjava.spring5.service;

import com.atjava.spring5.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
@Service(value = "bookService")

public class BookService {
    // 注入属性：
    @Autowired
    @Qualifier(value = "bookDaoImpl")
    private BookDao bd;

}

package com.atjava.spring5.dao;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
public interface BookDao {
}

package com.atjava.spring5.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */

@Repository(value = "bookDaoImpl")
public class BookDaoImpl implements BookDao {

    // 注入 JdbcTemplate
    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
}

JdbcTemplate操作（添加数据）

数据的增删改操作都是调用 JdbcTemplate的 update()方法

USE user_db;
CREATE TABLE t_user(
	user_id BIGINT,
	username VARCHAR(100),
	ustatus VARCHAR(50)
);

创建对应数据库实体类：

package com.atjava.spring5.entity;

/**
 * @author lv
 * @create 2021-12-22 22:11
 */
public class User {
    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;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId='" + userId + ''' +
                ", username='" + username + ''' +
                ", ustatus='" + ustatus + ''' +
                '}';
    }
}

编写 service和 dao

service模拟接口请求，发起数据添加操作：

package com.atjava.spring5.service;

import com.atjava.spring5.dao.BookDao;
import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
@Service(value = "bookService")

public class BookService {
    // 注入属性：
    @Autowired
    @Qualifier(value = "bookDaoImpl")
    private BookDao bd;

    // 添加的方法
    public void addBook(Book book) {
        bd.add(book);
    }

}

在 dao中进行数据库添加操作：

使用 JdbcTemplate的 update()方法，操作数据库
jdbcTemplate.update(sql, args);

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
public interface BookDao {
    // 数据添加方法
    public void add(Book book);
}

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */

@Repository(value = "bookDaoImpl")
public class BookDaoImpl implements BookDao {

    // 注入 JdbcTemplate
    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        // 1.创建 sql语句
        String sql = "insert into t_book values(?,?,?)";
        // 2.调用方法实现
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        // int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        int update = jdbcTemplate.update(sql, args);

        System.out.println("sql: " + update);
        // sql: 1
    }
}

测试类：

package com.atjava.spring5.test;

import com.atjava.spring5.entity.Book;
import com.atjava.spring5.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author lv
 * @create 2021-12-22 22:34
 */
public class testBook {
    @Test
    public void testJdbcTemplateBookDao() {
        Book book = new Book();
        book.setUserId("789456123");
        book.setUsername("lv");
        book.setUstatus("ok");
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        bookService.addBook(book);
    }
}

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

数据的增删改操作都是调用 JdbcTemplate的 update()方法
BookService

package com.atjava.spring5.service;

import com.atjava.spring5.dao.BookDao;
import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
@Service(value = "bookService")

public class BookService {
    // 注入属性：
    @Autowired
    @Qualifier(value = "bookDaoImpl")
    private BookDao bd;

    // 添加的方法
    public void addBook(Book book) {
        bd.add(book);
    }

    // 修改的方法
    public void updateBook(Book book) {
        bd.updateBook(book);
    }

    // 删除的方法
    public void deleteBook(String id) {
        bd.deleteBook(id);
    }

}

BookDao

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
public interface BookDao {
    // 数据添加方法
    public void add(Book book);
    // 数据修改方法
    public void updateBook(Book book);
    // 数据删除方法
    public void deleteBook(String id);
}

BookDaoImpl

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */

@Repository(value = "bookDaoImpl")
public class BookDaoImpl implements BookDao {

    // 注入 JdbcTemplate
    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    // 添加操作
    @Override
    public void add(Book book) {
        // 1.创建 sql语句
        String sql = "insert into t_book values(?,?,?)";
        // 2.调用方法实现
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        // int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        int update = jdbcTemplate.update(sql, args);

        System.out.println("add: " + update);
        // sql: 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: " + update);
    }

    // 删除操作
    @Override
    public void deleteBook(String id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println("delete: " + update);
    }
}

test

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

    // 修改操作
    Book book = new Book();
    book.setUserId("789456123");
    book.setUsername("lw2");
    book.setUstatus("no");
    bookService.updateBook(book);
}

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

    // 删除操作
    Book book = new Book();
    book.setUserId("789456123");
    book.setUsername("lw2");
    book.setUstatus("no");
    bookService.deleteBook(book.getUserId());
}

JdbcTemplate操作数据库（查询）

返回单个值

查询单个表中有多少条记录，返回单个值
使用 JdbcTemplate实现查询返回单个值
queryForObject(sql, Class<> class)

// 查询获取单个值
@Override
public int selectCount() {
    String sql = "select count(*) from t_book";
    Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
    return integer;
}

返回对象

场景：查询图书详情
JdbcTemplate实现查询返回对象
queryForObject(String sql, RowMapper rowMapper, Object... args);
- RowMapper是一个接口，针对返回不同类型数据，使用此接口的实现类完成数据的封装

// 查询获取单个对象
public Book selectOne(String id) {
    String sql = "select user_id, username, ustatus from t_book where user_id=?";
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
    return book;
}

返回 list集合

场景：查询图书列表...
使用 JdbcTemplate实现查询返回列表
query(sql, RowMapper rowMapper, Object... args)
- RowMapper是一个接口，针对返回不同类型数据，使用此接口的实现类完成数据的封装

// 查询返回list
public List<Book> selectList() {
    String sql = "select user_id, username, ustatus from t_book";
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

JdbcTemplate操作数据库（查询操作，完整示例）

BookService.java

package com.atjava.spring5.service;

import com.atjava.spring5.dao.BookDao;
import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
@Service(value = "bookService")

public class BookService {
    // 注入属性：
    @Autowired
    @Qualifier(value = "bookDaoImpl")
    private BookDao bd;

    // 添加的方法
    public void addBook(Book book) {
        bd.add(book);
    }

    // 修改的方法
    public void updateBook(Book book) {
        bd.updateBook(book);
    }

    // 删除的方法
    public void deleteBook(String id) {
        bd.deleteBook(id);
    }

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

    // 查询，获取一个对象
    public Book findOne(String id) {
        return bd.selectOne(id);
    }
    // 查询，返回一个list
    public List<Book> findList() {
        return bd.selectList();
    }

}

BookDao.java

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;

import java.util.List;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */
public interface BookDao {
    // 数据添加方法
    public void add(Book book);
    // 数据修改方法
    public void updateBook(Book book);
    // 数据删除方法
    public void deleteBook(String id);
    // 查询单个数值
    public int selectCount();
    // 查询，获取一个对象
    public Book selectOne(String id);
    // 查询，返回一个list
    public List<Book> selectList();
}

BookDaoImpl.java

package com.atjava.spring5.dao;

import com.atjava.spring5.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @author lv
 * @create 2021-12-20 22:37
 */

@Repository(value = "bookDaoImpl")
public class BookDaoImpl implements BookDao {

    // 注入 JdbcTemplate
    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    // 添加操作
    @Override
    public void add(Book book) {
        // 1.创建 sql语句
        String sql = "insert into t_book values(?,?,?)";
        // 2.调用方法实现
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        // int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        int update = jdbcTemplate.update(sql, args);

        System.out.println("add: " + update);
        // sql: 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: " + update);
    }

    // 删除操作
    @Override
    public void deleteBook(String id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println("delete: " + update);
    }

    // 查询获取单个值
    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        return integer;
    }
    // 查询获取单个对象
    public Book selectOne(String id) {
        String sql = "select user_id, username, ustatus from t_book where user_id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }
    // 查询返回list
    public List<Book> selectList() {
        String sql = "select user_id, username, ustatus from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }
}

test

// 查询，获取单个值
@Test
public void testJdbcTemplateQuery1() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bs = context.getBean("bookService", BookService.class);

    int count = bs.findCount();
    System.out.println("count：" + count);
}

// 查询，返回单个对象
@Test
public void testJdbaTemplateQuery2() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bs = context.getBean("bookService", BookService.class);
    Book bsOne = bs.findOne("789456123");
    System.out.println("bsOne：" + bsOne);
}
// 查询，返回list
@Test
public void testJdbcTemplateQuery3() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bs = context.getBean("bookService", BookService.class);
    List<Book> bookList = bs.findList();
    System.out.println("bookList：" + bookList);
}

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

批量操作，同时向表中添加、修改、删除多条记录

JdbcTemplate实现批量添加操作

batchUpdate(String sql, List<Object[]> batchArgs);
- List集合，添加多条记录

@Override
public void batchAddBook(List<Object[]> batchArgs) {
    String sql = "insert into t_book values(?,?,?)";
    // 底层是遍历 batchArgs，分别调用 sql进行添加操作
    int[] batchUpdate = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println("batchUpdate: " + Arrays.toString(batchUpdate));
}

test

// 批量添加
@Test
public void testJdbcTemplateBatch1() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);
    List<Object[]> list = new ArrayList();
    Object[] o1 = {"123", "lv2", "yes"};
    Object[] o2 = {"456", "lv3", "no"};
    Object[] o3 = {"789", "lv4", "yes"};
    list.add(o1);
    list.add(o2);
    list.add(o3);
    bookService.batchAdd(list); // batchUpdate: [1, 1, 1]
}

JdbcTemplate实现批量修改操作

batchUpdate(String sql, List<Object[]> batchArgs);

// 批量修改
@Override
public int[] batchUpdates(List<Object[]> batchArgs) {
    String sql = "update t_book set username=?, ustatus=? where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    return ints;
}

test

// 批量修改
@Test
public void testJdbcTemplateBatch2() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);
    List<Object[]> list = new ArrayList<>();
    Object[] o1 = new Object[3];
    o1[0] = "lv5";
    o1[1] = "no";
    o1[2] = "789";
    Object[] o2 = {"lv3", "yes", "456"};
    Object[] o3 = {"lv21", "yes", "123"};
    list.add(o1);
    list.add(o2);
    list.add(o3);
    int[] ints = bookService.batchUpdates(list);
    System.out.println("batchUpdates: " + Arrays.toString(ints));
}

JdbcTemplate实现批量删除操作

batchUpdate(String sql, List<Object[]> batchArgs);

// 批量删除
@Override
public void batchDeletes(List<Object[]> batchArgs) {
    String sql = "delete from t_book where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println("batchDeletes: " + Arrays.toString(ints));
}

test

// 批量删除
@Test
public void testJdbcTemplateBatch3() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bs = context.getBean("bookService", BookService.class);
    List<Object[]> list = new ArrayList<>();
    Object[] o1 = {"123"};
    Object[] o2 = {"456"};
    Object[] o3 = {"789"};
    list.add(o1);
    list.add(o2);
    list.add(o3);
    bs.batchDeletes(list);
}

Spring5 基础2

IOC 容器

IOC 操作 Bean 管理（基于注解方式）

完全注解开发

AOP：面向切面编程

AOP：底层原理

AOP 底层使用动态代理

AOP 术语

AOP 操作（准备）

AOP 操作（AspectJ 注解方式）

公共切入点抽取

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

AOP 操作 （AspectJ xml配置文件方式）

JdbcTemplate

JdbcTemplate操作（添加数据）

创建对应数据库实体类：

编写 service和 dao

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

JdbcTemplate操作数据库（查询）

JdbcTemplate操作数据库（查询操作，完整示例）

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

JdbcTemplate实现批量添加操作

JdbcTemplate实现批量修改操作

JdbcTemplate实现批量删除操作

AOP 操作（AspectJ xml配置文件方式）