@Configuration//标志该文件将代替xml作为配置文件
@ComponentScan(basePackages = {"com.atguigu"})//开启扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启事务
public class SpringConfig {
///创建数据库连接池
@Bean
public DruidDataSource getDruidDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("${jdbc.driver}");
dataSource.setUrl("jdbc:mysql://localhost:3306/t_account?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&rewriteBatchedStatements=true");
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;
}
}
@Test
public void test3(){
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
User user = context.getBean("user", User.class);
user.add();
}
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<version>2.6.3</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
</dependencies>
目录
1、在 service 类上面(或者 service 类里面方法上面)添加事务注解
一、AOP
1.什么是AOP-aspect oriented programming
(1)通俗描述:不通过修改源代码方式,在主干功能里面添加新功能
(2)面向切面编程(方面),利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得 业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
2.AOP的底层原理
1、AOP 底层使用动态代理
有两种情况的动态代理
2、JDK 动态代理
调用 newProxyInstance 方法,这个方法返回的是Object类型,需要强转一下类型
方法有三个参数:
第一参数,类加载器
第二参数,增强方法所在的类,这个类实现的接口,支持多个接口,是一个数组类型
第三参数,实现这个接口 InvocationHandler,创建代理对象,写增强的部分
public class JDKProxy {
@Test
public void proxyTest(){
Class[] interfaces={UserDao.class};
UserDaoImpl userDao = new UserDaoImpl();
UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
dao.add();
}
}
public class UserDaoProxy implements InvocationHandler {
Object obj;
public UserDaoProxy(Object obj) {
this.obj=obj;
}
//invoke方法中如果不对method进行判断就是,对obj类中的所有方法进行增强
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前
System.out.println("之前的操作");
//增强的方法
Object res = method.invoke(obj, args);
//方法之后
System.out.println("之后的操作");
return res;
}
}
3、AOP(术语)
(1)连接点:类中可以被被增强的方法叫连接点
(2)切入点:类中实际被增强的方法叫切入点
(3)通知/增强:实际增强的逻辑部分
(4)切面:是动作,把通知应用到切入点的过程
通知的分类(以上面增强add()方法为例)
前置通知:注解是@Before add()之前执行的通知
后置通知:注解是@AfterReturning add()之后执行的通知,add()出现异常就不会执行的通知
环绕通知:注解是@Around add()前后都会执行的通知
异常通知:注解是@AfterThrowing 有异常时才会执行的通知
最终通知:注解是@After 类似于finally,不管有没有异常都会执行的通知
4、切入点表达式
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构: execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
权限修饰符:用 * 表示所有的权限修饰符P
返回类型可以省略不写
[类全路径] [方法名称] 连在一起写;特别的该类中所有方法用*,举例2和3
参数列表固定写法:(..)
举例 1:对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
举例 2:对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (..))
举例 3:对 com.atguigu.dao 包里面所有类,类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))
(2)使用方法
举例@Before(value = "execution(* com.atguigu.dao.BookDao.add(..))")
5、AOP操作
(1)Spring 框架一般都是基于 AspectJ 实现 AOP 操作,在项目工程里面引入 AOP 相关依赖
(2)完全注解开发的配置文件
@Configuration//标志该文件将代替xml作为配置文件
@ComponentScan(basePackages = {"com.atguigu"})//开启扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启AOP
public class SpringConfig {
//接下来数数据库的配置
@Bean
public DruidDataSource getDruidDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("${jdbc.driver}");
dataSource.setUrl("jdbc:mysql://localhost:3306/t_account?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&rewriteBatchedStatements=true");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
//到 ioc 容器中根据类型找到 dataSource
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//注入 dataSource
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
}
(3)
增强类于被增强类都需要注解@Component/@Service/...
增强类需要注解@Aspect
@Component
public class User {
public void add(){
System.out.println("user...add..");
}
}
@Component
@Aspect
public class UserProxy {
@Before(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void before(){
System.out.println("前置通知...");
}
@Around(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知1...");
proceedingJoinPoint.proceed();
System.out.println("环绕通知2...");
}
@AfterReturning(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void afterReturning(){
System.out.println("后置通知.....");
}
@AfterThrowing(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void afterThrowing(){
System.out.println("异常通知....");
}
@After(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void after(){
System.out.println("最终通知...");
}
}
(4) 优化:(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")重复出现
//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
System.out.println("before.........");
}
//优化后
@Component
@Aspect
public class UserProxy {
@Pointcut(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
public void pointCut(){}
@Before(value = "pointCut()")
public void before(){
System.out.println("前置通知...");
}
@Around(value = "pointCut()")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知1...");
proceedingJoinPoint.proceed();
System.out.println("环绕通知2...");
}
@AfterReturning(value = "pointCut()")
public void afterReturning(){
System.out.println("后置通知.....");
}
@AfterThrowing(value = "pointCut()")
public void afterThrowing(){
System.out.println("异常通知....");
}
@After(value = "pointCut()")
public void after(){
System.out.println("最终通知...");
}
}
(5)有多个增强类多同一个方法进行增强,设置增强类优先级
在增强类上面添加注解 @Order(数字类型值),数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{}
(6)测试
@Test
public void test3(){
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
User user = context.getBean("user", User.class);
user.add();
}
二、JdbcTemplate
1.什么是 JdbcTemplate
Spring 框架对 JDBC 进行封装,使用 JdbcTemplate 方便实现对数据库操作
2.API
(1):添加,删除,修改:update( String sql,Object. .. args)
(2)查询返回某个值:queryForObject(String sql,Class<T> requiredType)
第二个参数 Class<T> requiredType
这个参数指的是你要的返回类型,你要integer类型就写Integer.class
___.class ___写的是类名
____.getclass ____写的是对象名
//查询表记录数
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
(2):查询返回单个对象 :queryForObject ( String sql,RowMapper<T> rowMapper,Object. .. args)
有三个参数
第一个参数: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;
}
(3)查询返回集合:query ( String sql,RowMapper<T> rowMapper,Object. .. args)
有三个参数
第一个参数: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;
}
(4)实现批量添加操作:batchUpdate( String sql, List<0bject[]> batchArgs)
返回一个数组,长度是batchArgs的长度
有两个参数
第一个参数:sql 语句
第二个参数:List 集合,添加,删除,修改多条记录数据
//添加
@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","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);
//批量修改
@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);
//批量删除
@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);
三、事务
1、在 service 类上面(或者 service 类里面方法上面)添加事务注解
(1)@Transactional,这个注解添加到类上面,也可以添加方法上面
(2)如果把这个注解添加类上面,这个类里面所有的方法都添加事务
(3)如果把这个注解添加方法上面,为这个方法添加事务
@Service
@Transactional
public class UserService {}
2.事务操作(声明式事务管理参数配置)
1)、在 service 类上面添加注解@Transactional,在这个注解里面可以配置事务相关参数
2)、propagation:事务传播行为:一个有事务调用一个无事务/一个有事务调用一个有事务/一个无事务调用一个有事务/一个无事务调用一个有事务
如下面 add是有事务,update是无事务,add调用update就是事务传播行为
事务的传播行为有7种,如何写(见下)
@Service
@Transactional(propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {
下面两种传播行为比较重要
3)、ioslation:事务隔离级别
(1)事务有特性成为隔离性,多事务操作之间不会产生影响。不考虑隔离性产生很多问题
(2)有三个读问题:脏读、不可重复读、虚(幻)读
(3)脏读:一个未提交事务读取到另一个未提交事务的数据
(4)不可重复读:一个未提交事务读取到另一提交事务修改数据
(5)虚读:一个未提交事务读取到另一提交事务添加数据
(6)解决:通过设置事务隔离级别,解决读问题
4)、timeout:超时时间 (1)事务需要在一定时间内进行提交,如果不提交进行回滚 (2)默认值是 -1 ,设置时间以秒单位进行计算
5)、readOnly:是否只读 (1)读:查询操作,写:添加修改删除操作 (2)readOnly 默认值 false,表示可以查询,可以添加修改删除操作 (3)设置 readOnly 值是 true,设置成 true 之后,只能查询
6)、rollbackFor:回滚 (1)设置出现哪些异常进行事务回滚
7)、noRollbackFor:不回滚 (1)设置出现哪些异常不进行事务回滚