Spring第二天

该文档是:Spring学习...

博客连接:https://www.loveuluo.cn

日期:2020-12-26

1. JdbcTemplate(概念和准备)

1、什么是 JdbcTemplate

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

2、准备工作

(1)引入相关 jar 包

image-20201226100559721

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

<!-- 数据库连接池 -->
<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="123456" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

(3)配置 JdbcTemplate 对象,注入DataSource

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

(4)创建 service 类,创建 dao 类,在 dao 注入 jdbcTemplate 对象

⚫ 配置文件

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

⚫ Service

@Service
public class BookService {
    //注入 dao
    @Autowired
    private BookDao bookDao;
}

⚫ Dao

@Repository
public class BookDaoImpl implements BookDao {
    //注入 JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

2. JdbcTemplate 操作数据库

2.1 添加

1、对应数据库创建实体类

public class Book {
    private String userId;
    private String username;
    private String ustatus;
}

2、编写 service 和 dao

(1)在 dao 进行数据库添加操作
(2)调用 JdbcTemplate 对象里面 update 方法实现添加操作

image-20201226102714484

⚫ 有两个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:可变参数,设置 sql 语句值

Service类:

@Service
public class BookService {
    //注入 dao
    @Autowired
    private BookDao bookDao;

    public void add(Book book){
       bookDao.add(book);
    }
}

Dao类:

@Repository
public class BookDaoImpl implements BookDao {
    //注入 JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public void add(Book book) {
        String sql="INSERT INTO t_book(user_id,username,ustatus) VALUES(?,?,?)";
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        System.out.println(update);
    }
}

3、测试类

@Test
public void Test04(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
    BookService service = context.getBean("bookService", BookService.class);
    Book book=new Book("1","曹新千","a");
    service.add(book);
}

image-20201226104129828

2.2 修改和删除

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);
}

2、删除

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

2.3 查询返回某个值

1、查询表里面有多少条记录,返回是某个值
2、使用 JdbcTemplate 实现查询返回某个值代码

image-20201226105857402

⚫ 有两个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:返回类型 Class

//查询表记录数
@Override
public int selectCount() {
    String sql = "select count(*) from t_book";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}

2.4 查询返回对象

1、场景:查询图书详情
2、JdbcTemplate 实现查询返回对象

image-20201226110737757

⚫ 有三个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:RowMapper 是接口,针对返回不同类型数据,使用这个接口里面实现类完成数据封装
⚫ 第三个参数:sql 语句

//查询返回对象
@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;
}

2.5 查询返回集合

1、场景:查询图书列表分页…
2、调用 JdbcTemplate 方法实现查询返回集合

image-20201226111108758

⚫ 有三个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:RowMapper 是接口,针对返回不同类型数据,使用这个接口里面实现类完成
数据封装
⚫ 第三个参数:sql 语句值

//查询返回集合
@Override
public List<Book> findAllBook() {
    String sql = "select * from t_book";
    //调用方法
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

2.6 批量操作

1、批量操作:操作表里面多条记录

2、JdbcTemplate 实现批量添加操作

image-20201226120621519

⚫ 有两个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:List 集合,添加多条记录数据

批量添加:

//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
    String sql = "insert into t_book values(?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); //影响行数 例如如果添加三个那么就是[1,1,1]
    System.out.println(Arrays.toString(ints));
}

批量添加测试:

//批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3", "java", "a"};
Object[] o2 = {"4", "c++", "b"};
Object[] o3 = {"5", "MySQL", "c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

3、JdbcTemplate 实现批量修改操作

批量修改:

//批量修改
@Override
public void batchUpdateBook(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 = {"java0909","a3","3"};
Object[] o2 = {"c++1010","b4","4"};
Object[] o3 = {"MySQL1111","c5","5"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);

4、JdbcTemplate 实现批量删除操作

批量删除:

//批量删除
@Override
public void batchDeleteBook(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"};
batchArgs.add(o1);
batchArgs.add(o2);
//调用方法实现批量删除
bookService.batchDelete(batchArgs);

3. 事务操作

3.1 事务概念

1、什么事务
(1)事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操
作都失败
(2)典型场景:银行转账

  • lucy 转账 100 元 给 mary
  • lucy 少 100,mary 多 100

2、事务四个特性(ACID)
(1)原子性
(2)一致性
(3)隔离性
(4)持久性

3.2 搭建事务操作环境

image-20201226170840391

1、创建数据库表,添加记录

image-20201226170850525

2、创建 service,搭建 dao,完成对象创建和注入关系

(1)service 注入 dao,在 dao 注入 JdbcTemplate,在 JdbcTemplate 注入 DataSource

@Service
public class UserService { 
    //注入 dao
    @Autowired
    private UserDao userDao;
}

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

3、在 dao 创建两个方法:多钱和少钱的方法,在 service 创建方法(转账的方法)

Dao:

    @Repository
    public class UserDaoImpl implements UserDao {
        @Autowired
        private JdbcTemplate jdbcTemplate;
        //lucy 转账 100 给 mary
        
        //少钱
        @Override
        public void reduceMoney() {
            String sql = "update t_account set money=money-? where username=?";
            jdbcTemplate.update(sql,100,"lucy");
        }
        
        //多钱
        @Override
        public void addMoney() {
            String sql = "update t_account set money=money+? where username=?";
            jdbcTemplate.update(sql,100,"mary");
        }
    }

Service:

@Service
public class UserService {
    //注入 dao
    @Autowired
    private UserDao userDao;
    //转账的方法
    public void accountMoney() {
    //lucy 少 100
        userDao.reduceMoney();
    //mary 多 100
        userDao.addMoney();
}

4、上面代码,如果正常执行没有问题的,但是如果代码执行过程中出现异常,有问题

image-20201226171251752

(1)上面问题如何解决呢?

使用事务进行解决

(2)事务操作的过程代码还未实现(这是编程式事务管理,比较复杂,声明式事务管理一个注解就能搞定)

image-20201226171337737

3.3 Spring 事务管理介绍

1、事务添加到 JavaEE 三层结构里面 Service 层(业务逻辑层)
2、在 Spring 进行事务管理操作
(1)有两种方式:编程式事务管理和声明式事务管理(一般使用声明式事务管理)
3、声明式事务管理
(1)基于注解方式(常用)
(2)基于 xml 配置文件方式
4、在 Spring 进行声明式事务管理,底层使用 AOP 原理
5、Spring 事务管理 API
(1)提供一个接口,代表事务管理器,这个接口针对不同的框架提供不同的实现类

image-20201226182540073

3.4 基于注解声明式事务管理

1、在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
    <!--注入数据源--> 
    <property name="dataSource" ref="dataSource"></property>
</bean>

2、在 spring 配置文件,开启事务注解

(1)在 spring 配置文件引入名称空间 tx

<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" 
 xmlns:tx="http://www.springframework.org/schema/tx" 
 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 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

(2)开启事务注解

<!--开启事务注解-->
<tx:annotation-driven transaction￾manager="transactionManager"></tx:annotation-driven>

3、在 service 类上面(或者 service 类里面方法上面)添加事务注解

(1)@Transactional,这个注解添加到类上面,也可以添加方法上面
(2)如果把这个注解添加类上面,这个类里面所有的方法都添加事务
(3)如果把这个注解添加方法上面,为这个方法添加事务

@Service
@Transactional
public class UserService {
}

3.5 声明式事务管理参数配置

1、在 service 类上面添加注解@Transactional,在这个注解里面可以配置事务相关参数

image-20201226185246906

2、propagation:事务传播行为

(1)多事务方法直接进行调用,这个过程中事务 是如何进行管理的

  • 事务的传播行为可以由传播属性指定。Spring定义了7种传播行为(前两种常用需要记住)

image-20201226185510197

  • 图解什么是传播行为和常用的前两种传播行为

image-20201226185309130

  • 在代码中如何配置(注解中不写的话默认的传播行为就是REQUIRED)

image-20201226185559805

3、ioslation:事务隔离级别

(1)事务有特性成为隔离性,多事务操作之间不会产生影响。不考虑隔离性产生很多问题
(2)有三个读问题:脏读、不可重复读、虚(幻)读
(3)脏读:一个未提交事务读取到另一个未提交事务的数据

image-20201226185806083

(4)不可重复读:一个未提交事务读取到另一提交事务修改数据

image-20201226185817560

(5)虚读:一个未提交事务读取到另一提交事务添加数据

(6)解决:通过设置事务隔离级别,解决读问题

image-20201226185838921

(7)在代码中如何配置(MySQL中的默认隔离级别就是REPEATABLE READ)

image-20201226185902346

4、timeout:超时时间

(1)事务需要在一定时间内进行提交,如果不提交进行回滚
(2)默认值是 -1 ,设置时间以秒单位进行计算

5、readOnly:是否只读
(1)读:查询操作,写:添加修改删除操作
(2)readOnly 默认值 false,表示可以查询,可以添加修改删除操作
(3)设置 readOnly 值是 true,设置成 true 之后,只能查询

6、rollbackFor:回滚
(1)设置出现哪些异常进行事务回滚

7、noRollbackFor:不回滚
(1)设置出现哪些异常不进行事务回滚

3.6 基于XML声明式事务管理

1、在 spring 配置文件中进行配置
第一步 配置事务管理器
第二步 配置通知
第三步 配置切入点和切面

    <!--1 创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--2 配置通知-->
    <tx:advice id="txadvice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
            <!--<tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
    <!--3 配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

3.7 完全注解声明式事务管理

1、创建配置类,使用配置类替代 xml 配置文件

    @Configuration //配置类
    @ComponentScan(basePackages = "com.atguigu") //组件扫描
    @EnableTransactionManagement //开启事务
    public class TxConfig {
        //创建数据库连接池
        @Bean
        public DruidDataSource getDruidDataSource() {
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql:///user_db");
            dataSource.setUsername("root");
            dataSource.setPassword("root");
            return dataSource;
        }
        //创建 JdbcTemplate 对象
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
            //到 ioc 容器中根据类型找到 dataSource
            JdbcTemplate jdbcTemplate = new JdbcTemplate();
            //注入 dataSource
            jdbcTemplate.setDataSource(dataSource);
            return jdbcTemplate;
        }
        //创建事务管理器
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
            DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
            transactionManager.setDataSource(dataSource);
            return transactionManager;
        }
    }

4. Spring5 框架新功能

1、整个 Spring5 框架的代码基于 Java8,运行时兼容 JDK9,许多不建议使用的类和方法在代码库中删除

2、Spring 5.0 框架自带了通用的日志封装
(1)Spring5 已经移除 Log4jConfigListener,官方建议使用 Log4j2
(2)Spring5 框架整合 Log4j2
第一步 引入 jar 包

第二步 创建 log4j2.xml 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
    <!--Configuration 后面的 status 用于设置 log4j2 自身内部的信息输出,可以不设置,当设置成 trace 时,可以看到 log4j2 内部各种详细输出-->
    <configuration status="INFO">
    <!--先定义所有的 appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-
5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义 logger,只有定义 logger 并引入的 appender,appender 才会生效-->
    <!--root:用于指定项目的根日志,如果没有单独指定 Logger,则会使用 root 作为默认的日志输出-->
    <loggers>
    <root level="info">
        <appender-ref ref="Console"/>
    </root>
    </loggers>
    </configuration>

3、Spring5 框架核心容器支持@Nullable 注解

(1)@Nullable 注解可以使用在方法上面,属性上面,参数上面,表示方法返回可以为空,属性值可以
为空,参数值可以为空
(2)注解用在方法上面,方法返回值可以为空

image-20201226200605611

(3)注解使用在方法参数里面,方法参数可以为空

image-20201226200613710

(4)注解使用在属性上面,属性值可以为空

image-20201226200620255

4、Spring5 核心容器支持函数式风格 GenericApplicationContext

    //函数式风格创建对象,交给 spring 进行管理
    @Test
    public void testGenericApplicationContext() {
        //1 创建 GenericApplicationContext 对象
        GenericApplicationContext context = new GenericApplicationContext();
        //2 调用 context 的方法对象注册
        context.refresh();
        context.registerBean("user1",User.class,() -> new User());
        //3 获取在 spring 注册的对象
        // User user = (User)context.getBean("com.atguigu.spring5.test.User");
        User user = (User)context.getBean("user1");
        System.out.println(user);
    }

5、Spring5 支持整合 JUnit5

(1)整合 JUnit4
第一步 引入 Spring 相关针对测试依赖

image-20201226200658089

第二步 创建测试类,使用注解方式完成

@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
@ContextConfiguration("classpath:bean1.xml") //加载配置文件
public class JTest4 { 
    @Autowired
    private UserService userService; 
    @Test 
    public void test1() {
        userService.accountMoney();
    }
}

(2)Spring5 整合 JUnit5
第一步 引入 JUnit5 的 jar 包

image-20201226200740766

第二步 创建测试类,使用注解完成

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
public class JTest5 {
    @Autowired
    private UserService userService; 
    @Test 
    public void test1() { 
        userService.accountMoney(); 
    }
}

(3)使用一个复合注解替代上面两个注解完成整合

@SpringJUnitConfig(locations = "classpath:bean1.xml")
public class JTest5 { 
    @Autowired 
    private UserService userService; 
    @Test 
    public void test1() { 
        userService.accountMoney(); 
    }
}
最后修改:2021 年 01 月 01 日 09 : 36 AM
如果觉得我的文章对你有用,请随意赞赏