1.spring是轻量级的开源javaee框架
2.spring可以解决企业应用开发的复杂性
3.spring有两个核心部分****ioc和aop
（1）ioc：控制反转，把创建对象过程交给spring进行管理
（2） Aop：面向切面，不修改源代码进行功能增强
4.# spring的特点
-
方便解耦，简化开发
-
aop编程支持
-
方便程序测试
-
方便与其他框架进行整合
-
方便进行食物 *** 作
-
降低api的开发难度
ioc容器（概念和原理）- 什么是ioc
-
控制反转，把对象创建和对象之间的调用过程 ，交给spring进行管理。
-
使用IOC目的，为了耦合度降低
2.ioc底层原理*
- xml解析，工厂模式，反射
-
3.ioc（接口）
-
ioc思想基于ioc容器完成，ioc容器底层就是对象工厂。
-
Spring提供ioc容器实现两种方式：（两个接口）-
- BeanFactory：Ioc容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用,加载配置文件的时候不会创建对象，在获取对象（使用）才会去创建对象
2. ApplicationContext：Beanfactory接口的子接口，提供更多更强大的功能。一般有开发人员使用。
- 加载配置文件时候就会把配置文件对象进行创建
3. ApplicationContext接口有实现类：
- 加载配置文件时候就会把配置文件对象进行创建
* **主要****FileSystemXmlApplicationContext** * **ClassPathXmlApplicationContext**-四.ioc *** 作Bean管理
-
什么是Bean管理
- Bean管理指的是两个 *** 作
- spring创建对象
- spring注入属性
- Bean管理指的是两个 *** 作
-
Bean管理 *** 作的两种方式
- 基于xml配置文件方式实现
- 基于注解方式实现
-
IOC *** 作Bean管理（基于xml方式）
-
基于xml方式创建对象
-
配置对象创建 <bean id="stu1" class="com.dhy.Student"/>- 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
- bean标签有很多属性，常用属性
*id属性：唯一标识。
*class属性：类全路径（包类路径
创建对象时候，默认也是执行无参数构造方法完成对象创建
-
基于xml方式注入属性
1.DI：依赖注入，就是注入属性。
-
第一种注入方式：使用set方法进行注入
-
创建类，定义属性对应的set方法
-
在spring配置文件配置对象创建，配置属性注入
-
-
-
第二种注入方式：使用有参数构造进行注入
-
创建类，定义属性，创建有参构造方法
-
在spring配置文件中进行配置
-
-
4.p名称空间注入
-
- BeanFactory：Ioc容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用,加载配置文件的时候不会创建对象，在获取对象（使用）才会去创建对象
IOC *** 作Bean管理（xml注入其他类型属性）
-
字面量
- null值
-
属性值包含特殊符号
1.把<>进行转义<：> 2.把带特殊符号内容写到CDATA>]]>
-
注入属性-外部bean2
-
创建两个类service和到类
-
在service调用dao里面的方法
-
在spring配置文件中进行配置
-
-
注入属性-内部bean和级联赋值
*一对多关系：部门和员工，
一个部门有多个员工，一个员工属于一个部门。
部门是一，员工是多。
4.注入属性-级联赋值
<bean id="emp" class="org.pojo.Emp"> <property name="ename" value="李三"/> <property name="eage" value="11"/> <property name="dept" ref="userdept"/> bean> <bean id="userdept" class="org.pojo.Dept"> <property name="dname" value="部门">property> bean>
IOC *** 作Bean管理（xml注入集合属性）
1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
-
创建类，定义数组，list，map，set类型属性，生成对应set方法
-
public class Stu { private String[] course; private Listlist; private Map sets; public void setCourse(String[] course) { this.course = course; } public void setList(List list) { this.list = list; } public void setMap(Map sets) { this.sets = sets; } public void test(){ System.out.println(Arrays.toString(course)); System.out.println(map); System.out.println(sets); System.out.println(list); } } -
在spring配置文件中进行配置
-
java课程 c++ 张三 小三 JAVA
4.在集合里面设置对象类型值
5.把集合注入部分提取出来
-
在spring配置文件中引入名称空间util
-
-
==使用util标签完成list集合注入提取 ==
-
java c++ python
IOC *** 作Bean管理（FactoryBean）
==*==Spring有两种类型bean，一种普通bean ，另外一种工厂bean（FactoryBean）
- 普通bean：在配置文件中定义bean类型就是返回类型
- 工厂bean：在配置文件定义bean类型可以和返回类型不一样
1.第一步，创建类，让这个类作为工厂bean，实现接口FactoryBean
2.实现接口里面的方法，在实现的方法中定义返回的bean类型
IOC *** 作Bean管理（bean的作用域）
* 在Spring里面，设置创建 bean实例是单实例还是多实例
* 在Spring里面，默认情况下，bean是单实例对象
==*==如何设置单实例还是多实例
-
在Spring配置文件中bean标签里面有属性((scope)用于设置单实例还是多实例
-
scope属性值
-
第一个值，默认值：singleton，表示是单实例对象
-
第二个值，prototype，表示多实例对象
-
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-blz0ZcAc-1648795550805)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220323143849176.png)]
- singleton和prototype的区别
- singleton是单实例，prototype是多实例
- 设置scope值是singleton时候，加载Spring配置文件时候就会创建单实例对象
- 设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象
说明了解
IOC *** 作Bean管理（bean生命周期）
- 生命周期
- 从对象创建到对象销毁的工程
- bean生命周期
- 通过构造器创建bean实例（无参数构造）
- 为bean的属性设置值和对其他bean引用（调用set方法）
- 调用bean的初始化的方法（需要进行配置初始化的方法）
- bean可以使用了（对象获取到了）
- 当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法
- 演示bean的生命周期
public class Order {
private String oname;
public String getOname() {
return oname;
}
public Order() {
System.out.println("第一步，执行了无参数构造创建bean实例");
}
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步，执行set方法设置属性值");
}
public void initMethod(){
System.out.println("第三步，执行初始化方法");
}
public void destoryMethod(){
System.out.println("第五步，执行销毁方法");
}
@Test
public void testbeans(){
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
Order order=context.getBean("order",Order.class);
System.out.println("第四步，获取到对象");
System.out.println(order.getOname());
context.close();
}
第一步，执行了无参数构造创建bean实例
第二步，执行set方法设置属性值
第三步，执行初始化方法
第四步，获取到对象
姓名
第五步，执行销毁方法
-
bean的后置处理器，bean的生命周期有七步- 通过构造器创建bean实例（无参数构造）
- 为bean的属性设置值和对其他bean引用（调用set方法）
- 把bean实例传递bean后置处理器的方法
- 调用bean的初始化的方法（需要进行配置初始化的方法）
- 把bean实例传递bean后置处理器的方法
- bean可以使用了（对象获取到了）
- 当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法
添加后置处理器
- 创建类，实现接口BeanPostProcessor，创建后置处理器，实现方法
IOC *** 作Bean管理（xml自动装配）
-
什么是自动装配
- 根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值进行注入
-
演示自动装配过程
-
byName（属性名）byType（属性类型）
-
```
-
IOC *** 作Bean管理（外部属性文件）
- 引入外部属性文件配置数据库连接池
- 创建外部属性文件，properties格式文件，写数据库信息
- 把外部properties属性文件引入到spring配置文件中
- 引入context
在 spring配置文件使用标签引入外部属性文件
IOC *** 作Bean管理（基于注解方式）
1.什么是注解
- 注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）
- 使用注解，注解作用在类上面，方法上面，属性上面。
- 使用注解目的，简化xml配置
2.Spring针对Bean管理中创建对象提供注解
-
@Component
-
@Service
-
@Controller
-
@Repository
*上面四个注解功能都是一样的，都可以用来创建bean实例
3.基于注解方式 实现对象创建
-
第一步，引入依赖
- spring-aop的依赖
-
第二步，开启组件扫描。
-
-
第三步，创建类，在类的上面添加对象注解
-
//在注解里面value属性值可以省略不写 //默认值是类名称，首字母小写 -
开启组件扫描的细节配置
4.基于注解方式实现属性注入
-
@AutoWired（Spring包）
- 根据属性类型进行自动装配
- 第一步把service和dao对象创建，在service和dao类添加创建对象注解
- 第二步在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解。
- 根据属性类型进行自动装配
-
@Qualifier（Spring包）
- 根据属性名称进行注入
- 这个@Qualifier注解的使用，和上面的@AutoWired一起使用
- 根据属性名称进行注入
-
@Resource（javax包中扩展包）
-
可以根据类型注入，可以根据名称注入
-
//@Resource//根据类型注入 @Resource（name="userDaoImol"）//根据名称进行注入 private UserDao userDao
-
-
@Value
- 注入普通类型属性
@Value(value="abc")
private String name;
完全注解开发
1.创建配置类，替代 xml配置文件
@Configuration //作为配置类替代xml文件
@ComponentScan(basePackages ={"com.dhy"})
public class SpringConfig {
}
@Test
public void test2() {
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
Student student = context.getBean("student", Student.class);
System.out.println(student);
student.test();
}
AOP(概念)
-
什么是AOP：
-
面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率* *
-
通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。
-
1.有两种情况代理
- 第一种 有接口情况，使用JDK动态代理
- 创建接口实现类代理对象，增强类的方法。
- 创建接口实现类代理对象，增强类的方法。
- 第二种没有接口情况，使用CGLIB动态代理
- 创建子类的代理对象，增强类的方法
AOP（JDK动态代理）
-
使用JDk动态代理，使用Proxy类里面的方法创建代理对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SqrAb9re-1648795550807)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324073327718.png)]
2.调用newProxyInstance方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eErNWgae-1648795550808)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324073513571.png)]
方法有三个参数：
- 第一个参数：类加载器。
- 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口。
- 第三参数：实现这个接口InvocationHandler创建代理对象，写增强的方法。
-
编写JDK动态代理代码
-
1.创建接口，定义方法。
-
public interface UserDao { public int add(int a,int b); public String update(String a); } -
2.创建接口实现类，实现方法。
-
public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) { return a+b; } @Override public String update(String a) { return a; } } -
3.使用Proxy类创建接口代理对象。
-
package com.dhy; import com.dhy.dao.UserDao; import com.dhy.dao.impl.UserDaoImpl; 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}; UserDao userDao=new UserDaoImpl(); UserDao dao= (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao)); int result=dao.add(1,5); System.out.println(result); }} 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; } }
-
AOP（术语）
- 连接点：
- 类里面哪些方法可以被增强，这些方法称为连接点。
- 类里面哪些方法可以被增强，这些方法称为连接点。
- 切入点
- 实际被真正增强的方法，称为切入点。
- 实际被真正增强的方法，称为切入点。
- 通知（增强）
- 实际增强的逻辑部分称为通知
- 通知五种类型
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
- 切面
- 是动作
- 把通知应用到切入点过程。
AOP *** 作（准备）
- 1.Spring框架一般都是基于AspectJ实现AOP *** 作
- 什么是AspectJ
- AspectJ不是Spring组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP *** 作。
- AspectJ不是Spring组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP *** 作。
- 基于AspectJ实现AOP *** 作
- 基于xml配置文件实现
- 基于注解方式实现（使用）
- 什么是AspectJ
- 在项目工程里面引入AOP依赖
org.springframework
spring-aop
5.2.15.RELEASE
-
切入点表达式
-
切入点表达式作用：知道对哪个类里面的哪个方法进行增强。
-
语法结构：
-
execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数名称]))
举例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..(…))
-
-
AOP *** 作（AspectJ注解）
-
创建类，在类里面定义方法。
//被增强类 @Component public class User { public void test1(){ System.out.println("User方法执行。。
。
。
。
"); } }
-
创建增强类（编写增强逻辑）
-
在增强类里面，创建方法，让不同的方法代表不同的通知类型
-
//增强类 @Component @Aspect public class UserProxy { @Before(value = "execution(* com.dhy.service.User.test1(..))") public void before() { System.out.println("方法之前执行。。
。
"); } }
-
-
进行通知的配置
-
1在Spring配置文件中，开启注解扫描。
-
使用注解创建User和UserProxy对象
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpvUF3qn-1648795550808)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324134746841.png)]
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kv7WVXxf-1648795550809)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324134713879.png)]
-
在增强类上面添加注解@Aspect
-
在Spring配置文件中开启生成代理对象```
-
-
配置不同类型的通知
- 在增强类的里面，在作为通知方法上面添加类型注解，使用切入点表达式配置
public class UserProxy {
//前置通知
@Before(value = "execution(* com.dhy.service.User.test1(..))")
public void before() {
System.out.println("方法之前执行。
。
。
");
}
//最终通知有异常也执行
@After(value = "execution(* com.dhy.service.User.test1(..))")
public void after() {
System.out.println("After方法执行。
。
。
");
}
//后置通知（返回通知）有异常不执行
@AfterReturning(value = "execution(* com.dhy.service.User.test1(..))")
public void afterReturning() {
System.out.println("AfterReturning。
。
。
");
}
//异常通知
@AfterThrowing(value = "execution(* com.dhy.service.User.test1(..))")
public void afterThrowing() {
System.out.println("AfterThrowing。
。
。
");
}
//环绕通知
@Around(value = "execution(* com.dhy.service.User.test1(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知之前。
。
。
");
proceedingJoinPoint.proceed();
System.out.println("环绕通知之后。
。
。
。
");
}
}
5.相同切入点抽取
-
@Pointcut(value = "execution(* com.dhy.service.User.test1(..))") public void pointdemo(){} @Before(value = "pointdemo()") public void before() { System.out.println("方法之前执行。。
。
"); }
6.有多个增强类对同一个方法进行增强，设置增强类优先级
- 在增强类上面添加注解@Order（数字类型值），数组类型值越小优先级越高（从0开始）
@Component
@Aspect
@Order(10)
public class PerosnProxy {
AOp *** 作（AspectJ配置文件）
完全使用注解开发
-
@Configuration//表示配置类 @ComponentScan(basePackages = {"com.dhy"}) @EnableAspectJAutoProxy(proxyTargetClass = true) public class ConfigAop { }
什么是jdbctemplate
- Spring框架对JDBC进行封装，使用jdbcTemplate方便实现对数据库的 *** 作
配置jdbcTemplate对象
-
1.引入相关依赖
-
在Spring配置文件中配置数据库连接对象
-
bean.xml
-
-
druid.properties
-
druid.driverClassName=com.mysql.cj.jdbc.Driver druid.url=jdbc:mysql://localhost:3306/book_spring?serverTimezone=UTC&rewriteBatchedStatements=true druid.username=root druid.password=密码 -
配置jdbcTemplate对象，并为dataSource属性注入到数据库连接池对象
-
-
开启组件扫描
-
-
创建对应的类并使用注创建对象，这里以 BookDAO.java，BookDAOImpl.java，BookService.java 为例
BookDAO.java -
package com.mcc.spring5Jdbc.dao; public interface BookDAO { } -
package com.mcc.spring5Jdbc.dao; @Repository public class BookDAOImpl implements BookDAO{ @Autowired//配置文件中已经创建该对象 private JdbcTemplate jdbcTemplate; } -
package com.mcc.spring5Jdbc.service; @Service public class BookService { @Autowired//注入 BookDAOImpl 对象 private BookDAO bookDAO; } - JdbcTemplate *** 作
| 方法 | 作用 |
|---|---|
| **update(String sql，Object… args) | 添加、修改、删除 |
| **queryForObject(String sql，Class requiredType) | 查询某个值 |
| queryForObject(String sql，RowMapper rowMapper，Object… args) | ** 查询某个对象 |
| query(String sql，RowMapper rowMapper，Object… args) | ** 查询某个集合** |
| batchUpdate(String sql，List | 批量添加、修改、删除 |
事物概念
-
上面是事务
- 事务是数据库 *** 作最基本单元，逻辑上一组 *** 作，要么都成功，如果有一个失败所有 *** 作都失败。
- 事务是数据库 *** 作最基本单元，逻辑上一组 *** 作，要么都成功，如果有一个失败所有 *** 作都失败。
-
经典场景
- 银行转账
-
事务四个特性（ACID）
- 原子性
- 一致性
- 隔离性
- 持久性
事务 *** 作过程：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qx6Blwsf-1648795550810)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220325121324407.png)]
-
事务 *** 作（Spring事务管理介绍）
-
事务添加到javaEE三层结构里面Service层（业务逻辑层）
-
在Spring进行事务管理 *** 作
- 有两种方式：编程式事务管理和声明事务管理（使用）
-
声明式事务管理
- 基于注解方式
- 基于xml配置文件方式
-
在Spring进行声明式事务管理，底层使用AOP原理。
-
Spring事务管理API
- 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
Spring 提供 PlatformTransactionManager 接口，实现对事务的管理 *** 作，对于不同的框架，提供不同的实现类，如：不整合其他外部框架时，使用 DataSourceTransactionManager 实现类；整合 MyBatis 框架时，使用 DataSourceTransactionManager 实现类。
-
-
事务 *** 作（注解声明式事务管理）
-
在Spring配置文件配置事务管理器
-
-
在Spring配置文件中，开启事务注解（在Spring配置文件中引入名称空间tx）
-
-
在要添加事务的类或方法上添加
@Transactional注解 -
@Transactional public class UserService { } -
注意：@Transactional 注解可以添加在类上面，也可以添加在方法上面
（1）若添加在类上面，表示为这个类内所有的方法都添加事务
（2）若添加在方法上面，表示为这个方法添加事务
-
-
事务 *** 作（声明式事务管理参数配置）、
- 在service类上面添加==@Transactional==,在这个注解里面可以配置事务相关参数
- propagation:事务传播行为
- 多事务方法直接进行调用，这个过程事务是如何进行管理的
- REQUIRED：如果 A 方法有事务，调用 B 方法后，B 使用 A 的事务；如果 A 方法没有事务，调用 B 方法之后，开启一个新的事务。
- REQUIRED_NEW：不论 A 方法有无事务，调用 B 方法后，都开启一个新的事务。
- ioslation:事务隔离级别
- 事务有个特性称为隔离性，多事务 *** 作之间不会产生影响，不考虑隔离性会产生很多问题
- 有三个读的问题：脏读，不可重复读，幻读
- 脏读：一个未提交事务读取到另一个未提交事务的数据
- 不可重复读：一个未提交事务读取到另一提交事务修改的数据。
- 虚读：一个未提交事务读取到另一提交事务添加的数据。
- 解决：通过设置事务隔离级别，解决读问题（MySQL 默认使用 REPEATABLE_READ）
- timeout：超时时间
- 事务需要在一定时间类进行提交，如果不提交进行回滚
- 默认值是-1，设置时间以秒进行计算。
- readOnly：是否只读
- 读：查询 *** 作。
写：添加修改删除 *** 作
- readOnly默认值是false，表示可以查询，可以添加修改删除 *** 作。
- 设置为true，只能查询。
- 读：查询 *** 作。
- rollbackFor：回滚
- 设置出现那些异常进行事务回滚。
- 设置出现那些异常进行事务回滚。
- noRollbackFor：不回滚
- 设置出现那些异常不进行事务回滚。
- 设置出现那些异常不进行事务回滚。
-
事务 *** 作（xml声明式事务管理）
-
在 spring 配置文件中进行配置：
（1）配置事务管理器
（2）配置事务通知
（3）配置切入点和切面 -
-
完全注解声明式事务管理
使用 配置类 代替 xml 配置文件.
-
@Bean：使用在方法上，在加载配置类时，自动执行该方法，获取返回值对象，保存到 IOC 容器中。
如何保证使用的是同一个数据库连接池对象？* -
将 DataSource 对象以参数形式传入到其他方法中，保证使用的是同一个数据库连接池对象。
原因：在加载配置类时，由于 @Bean 注解的作用，会自动调用方法，因为方法的形参为 DataSource 对象，Spring 会自动在 IOC 容器中寻找 DataSource 对象，并传入方法中。package com.mcc.spring5.jdbc.transaction.config; import java.io.IOException; import java.io.InputStream; import java.util.Properties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import com.alibaba.druid.pool.DruidDataSource; //Spring配置类 @Configuration//声明配置类 @EnableTransactionManagement//开启事务注解 @ComponentScan(basePackages = {"com.mcc.spring5.jdbc.transaction"})//开启组件扫描 public class TxConfig { //创建数据库连接池对象 @Bean public DruidDataSource getDruidDataSource() { //加载配置文件 Properties prop = new Properties(); InputStream inputStream = TxConfig.class.getClassLoader().getResourceAsStream("druid2.property"); try { prop.load(inputStream); } catch (IOException e) { throw new RuntimeException("Error load file named druid2.property"); } //创建druid对象 DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(prop.getProperty("druid.driverClassName")); dataSource.setUrl(prop.getProperty("druid.url")); dataSource.setUsername(prop.getProperty("druid.username")); dataSource.setPassword(prop.getProperty("druid.password")); return dataSource; } //创建JdbcTemplate对象 @Bean public JdbcTemplate getJdbcTemplate(DruidDataSource dataSource) { JdbcTemplate jdbcTemplate = new JdbcTemplate(); jdbcTemplate.setDataSource(dataSource); return jdbcTemplate; } //创建事务管理器对象 @Bean public DataSourceTransactionManager getDataSourceTransactionManager(DruidDataSource dataSource) { DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); transactionManager.setDataSource(dataSource); return transactionManager; } }
@Test
public void testConfig() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
UserService userService = context.getBean("userService", UserService.class);
userService.accountMoney();
context.close();
}
Spring5框架新功能
-
spirng框架整合Log4j2
-
第一步引入jar包
-
-
org.apache.logging.log4j log4j-api2.13.1 org.apache.logging.log4j log4j-core2.13.1 org.apache.logging.log4j log4j-slf4j-impl2.13.1 test org.slf4j slf4j-api1.7.36 -
创建 Log4j 配置文件
注意：名称必须为log4j2.xml -
<configuration status="INFO"> <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> <loggers> <root level="info"> <appender-ref ref="Console"/> root> loggers> configuration>
-
-
st
org.slf4j
slf4j-api
1.7.36
```
*
* 创建 Log4j 配置文件
注意：名称必须为`log4j2.xml`
* ```xml
```
*
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）