Spring的使用
1、回顾下MVC的三层架构
2、Spring是什么
Spring是Spring这个团队开发的一个框架 ，这个框架既能为业务逻辑层提供事务，还能整合第三方框架，还提供了DAO层的解决方案(JDBCTemplate)，还提供了控制器的解决方案(springMVC)，同时还提供了AOP编程的思想的这样一个框架
以后只要是Java开发都会使用到这个框架
控制反转(IOC)、依赖注入(DI)、面向切面编程(AOP)，降低了组件之间的耦合度，使得代码更加模块化和易于测试
Spring框架采用了模块化的设计方式，将不同的功能划分到不同的模块中，如Spring Core、Spring Context、Spring AOP、Spring Web等
易于测试，Spring框架支持JUnit等测试框架，并提供了丰富的测试支持功能，如依赖注入测试等，这些功能使得开发者可以更加方便地进行单元测试、集成测试等，提高了代码的质量和可维护性
Spring框架是一个轻量级的框架，它的运行开销相对较小，不会给应用带来过多的负担
3、Spring能干什么
1、为业务逻辑层提供事务
2、整合第三方框架
3、提供了AOP编程的思想
4、提供了控制器的解决方案(SpringMVC)
5、提供了DAO层的解决方案(JDBCTemplate)
6、Spring在开发中其实最大的功能是解耦
4、Spring中的七大模块都有哪些功能
Spring Core：核心模块，主要提供了两个东西
1、IOC(控制反转)
以前在Java中创建对象是程序员来完成要么通过(new 反射 克隆clone())，这个创建对象是程序员完成的…
学习了Spring之后 这个对象的创建 可以交给 Spring去完成
控制反转：谁控制了谁？什么东西反转了呢? Spring控制了这个对象的创建权利 什么东西反转了呢?创建对象的权利反转了…2、DI(依赖注入)
依赖：我们在开发中 一个类A中维护了类B 我们就认为 类A依赖于类B 比如:控制器 Service DAO 我们可以认为控制器 依赖于Service Service依赖于DAO
注入：给成员变量赋值 只不过这个值 是从Spring的容器中去拿的IOC和DI是Spring框架的核心思想，有助于提升应用的可维护性和可扩展性
AOP模块：这是一种编程思想 – 面向切面编程
就是我们在写代码的时候 会出很多重复的代码、然后我们可以将这些重复的代码 抽取到一个指定的类中去 这个类就叫做切面类(工具类) 然后在原来代码正常执行的时候 通过代理的设计模式 动态的将这些代码植入到原来的位置让原来的程序 能够正常运行的这种编程思想 就叫做 面向切面编程
WebMVC模块:这个模块就是SpringMVC(控制器的解决方案) -这个就是我们二阶段写的这个框架
ORM：
O:Object
R:Relation
M:Mapping
对象 关系 映射
连起来就是 将Java对象 通过 映射关系 映射到数据库
整合第三方的DAO层框架的(Hibernate、mybatis)
DAO:这个就是 Spring提供的 DAO层的解决方案(JdbcTemplate)
Spring DAO提供了对JDBC和ORM（对象关系映射）技术的抽象和封装，就是JdbcTemplate，简化了数据访问层的开发
Web：是Spring对web项目的支持
Spring Context（应用上下文）：程序运行环境所封装的对象
- Spring Context建立在Spring Core之上，提供了更丰富的功能，如事件传播、资源加载等
- 它还提供了对Bean生命周期的管理，包括Bean的创建、初始化、销毁等
5、Spring下的第一个Helloworld程序(IOC)
5.1、导包
<!--导包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.26</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<!--这个是面向切面编程的包 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.20</version>
</dependency>
</dependency>
5.2、编写配置文件bean-base.xml
在main包新建一个resources文件夹，新建一个bean-base.xml配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">
<!-- 创建对象了-->
<bean id="user" class="com.qfedu.edu.pojo.User"></bean>
<bean id="user1" class="com.qfedu.edu.pojo.User"></bean>
</beans>
新建实体类user
package com.qfedu.edu.pojo;
@Data
public class User {
private Integer id;
private String username;
private String password;
}
5.3、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-base.xml");
//第二步：就可以从容器中找我们需要的对象了
// User user = context.getBean(User.class);
//通过配置文件的Id来查询，防止出错
User user = (User) context.getBean("user");
System.out.println("创建的用户对象是:" + user);
context.stop();
context.close();
}
创建的用户对象是:User(id=null, username=null, password=null)
6、Spring下的IOC
IOC(控制反转)
以前在Java中创建对象是程序员来完成要么通过(new 反射 克隆)，这个创建对象是程序员完成的…
学习了Spring之后 这个对象的创建 可以交给 Spring去完成
控制反转：谁控制了谁？什么东西反转了呢? Spring控制了这个对象的创建权利 什么东西反转了呢?创建对象的权利反转了…
6.0、创建对象的属性解析
实体类
package com.qfedu.edu.pojo;
@Data
public class User {
private Integer id;
private String username;
private String password;
public void init(){
System.out.println("初始化方法执行了....");
}
public void destory(){
System.out.println("---------destory执行了------------");
}
}
配置文件bean-base.xml
<!-- 创建对象了
id：对象的唯一标识
class：创建对象的类是谁
name：给对象取名字
scope：singleton：表示创建的对象是单例的(默认情况)
prototype：这个表示的是多例 多例是不会放到IOC容器的 只有单例才会放到IOC容器
所以 IOC容器还有一个名字叫做 单例池
init-method：对象放到IOC容器去之后 需要回调的方法是啥
destroy-method：这个表示的是 对象销毁的时候要执行的资源回收的方法
lazy-init="true" ：是否懒加载这个对象
默认情况下 容器一旦初始化 就会创建对象 如果设置了lazy-init="true"
那么这个对象容器初始化的时候 是不会创建的 要等到 第一次使用这个对象的时候才会创建
-->
<bean id="user" lazy-init="true" init-method="init" destroy-method="destory" class="com.qfedu.edu.pojo.User"></bean>
初始化方法执行了…
创建的用户对象是:User(id=null, username=null, password=null)
---------destory执行了------------
6.1、创建无参的对象
默认情况下 调用的就是无参构造器创建的Java对象
<bean id="user" class="com.qfedu.edu.pojo.User"></bean>
6.2、创建带参数的对象
<!-- 下面调用的是调用有有参数的构造器 完成对象的创建
调用有参数的构造器创建对象的第一种方式，不用
-->
<bean id="user2" class="com.qfedu.edu.pojo.User">
<constructor-arg index="0" value="1"></constructor-arg>
<constructor-arg index="1" value="小波波"></constructor-arg>
<constructor-arg index="2" value="123"></constructor-arg>
</bean>
<bean id="user3" class="com.qfedu.edu.pojo.User">
<constructor-arg name="id" value="1"></constructor-arg>
<constructor-arg name="username" value="小波波"></constructor-arg>
<constructor-arg name="password" value="123"></constructor-arg>
</bean>
创建的用户对象是:User(id=1, username=小波波, password=123)
6.3、通过静态工厂创建对象
6.3.1、创建工厂类
public class UserFactory {
//通过静态工厂创建Java对象
public static User getStaticUser() {
return new User(-1, "静态工厂创建的Java对象", "嘿嘿");
}
}
6.3.2、编写描述
<!-- 下面演示通过工厂创建对象-->
<!-- 通过静态工厂创建Java对象-->
<bean id="user4" class="com.qfedu.edu.fatory.UserFactory" factory-method="getStaticUser"></bean>
创建的用户对象是:User(id=-1, username=静态工厂创建的Java对象, password=嘿嘿)
6.4、通过非静态工厂创建对象
6.4.1、创建工厂类
public class UserFactory {
//通过非静态的工厂创建Java对象
public User getNormalUser() {
return new User(1, "非静态工厂创建的Java对象", "哈哈");
}
}
6.4.2、创建描述
<!-- 通过非静态的工厂创建Java对象-->
<!-- 创建出这个工厂的实例-->
<bean id="userFactory" class="com.qfedu.edu.fatory.UserFactory"></bean>
<!-- 第二步：通过工厂实例去调用非静态的方法创建对象
factory-bean：这个就是对象创建要依赖的这个工厂实例
这个值 需要从IOC容器中去找 这里直接写需要引用的实例的名字就可以了
-->
<bean id="user5" factory-bean="userFactory" factory-method="getNormalUser"></bean>
创建的用户对象是:User(id=1, username=非静态工厂创建的Java对象, password=哈哈)
7、Spring下的DI
DI(依赖注入)
依赖：我们在开发中 一个类A中维护了类B 我们就认为 类A依赖于类B 比如:控制器 Service DAO 我们可以认为控制器 依赖于Service Service依赖于DAO
注入：给成员变量赋值 只不过这个值 是从Spring的容器中去拿的依赖注入：就是给类中的成员变量赋值 这个值 必须来自于IOC容器
依赖注入是有个前提：如果需要给这个成员变量赋值的话 并且需要从IOC容器中去拿这个值的话 那么这个类本身也需要放到IOC容器
降低代码耦合度：依赖注入通过减少代码之间的直接依赖，使得各个模块或类更加独立，从而提高了代码的可维护性和可扩展性
增强模块化和可重用性：当组件之间的依赖关系被明确地管理时，它们可以更容易地被重新组合和重用
7.1、通过Set注入(开发中使用的最多的一种)
通过set方法将依赖项注入到对象中。这种方式使得依赖项不是必须的，即对象可以在没有依赖项的情况下被创建，然后在需要时注入依赖项
7.1.1、编写UserService
在service方法中调用其他类（IOC容器里的）的方法
package com.qfedu.edu.di;
public class UserService implements IUserService{
private IUserDAO userDAO;
//这个才是重要的
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
userDAO.print();
}
}
7.1.2、编写UserDAO
public class UserDAO implements IUserDAO{
public void print() {
System.out.println("------------DAO执行了---------");
}
}
7.1.3、编写描述
注意：两个类都要放在IOC容器里
<bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
<!--
value：是赋予一个具体的值
ref：表示的是引用IOC中的一个对象一般就是id的名字，这样他就会自动去IOC容器中去找这个对象进行赋值
-->
<bean id="userService" class="com.qfedu.edu.di.UserService">
<property name="userDAO" ref="userDAO"></property>
</bean>
7.1.4、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-di.xml");
//第二步：就可以从容器中找我们需要的对象了
UserService userService = context.getBean(UserService.class);
userService.print();
context.stop();
context.close();
}
------------DAO执行了---------
7.2、通过P标签注入
前提：这个成员变量也必须提供set方法
也就是说从底层的角度来说 p标签注入也是 set注入的一种
7.2.1、编写UserService
package com.qfedu.edu.di;
public class UserService implements IUserService{
private IUserDAO userDAO;
private String str;
public void setStr(String str) {
this.str = str;
}
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
System.out.println("str的值是:"+str);
userDAO.print();
}
}
7.2.2、编写描述
<!-- 下面研究的是p标签注入-->
<bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
<bean id="userService" class="com.qfedu.edu.di.UserService" p:userDAO-ref="userDAO" p:str="小波波你好呀"></bean>
7.3、通过内部bean注入
内部bean注入的前提是这个成员变量也必须设置 set方法才行 所以内部bean注入 你可以看成也是set注入
7.3.1、编写UserService
package com.qfedu.edu.di;
public class UserService implements IUserService{
private IUserDAO userDAO;
private String str;
public void setStr(String str) {
this.str = str;
}
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
System.out.println("str的值是:"+str);
userDAO.print();
}
}
7.3.2、编写配置
<!-- 下面研究的是内部bean注入 几乎不用-->
<bean id="userService" class="com.qfedu.edu.di.UserService">
<property name="userDAO">
<bean class="com.qfedu.edu.di.UserDAO"></bean>
</property>
<property name="str">
<bean class="java.lang.String">
<constructor-arg name="buffer" value="美女好"></constructor-arg>
</bean>
</property>
</bean>
7.4、通过构造器注入
通过构造函数将依赖项传递给对象。Spring在创建对象时会查找匹配的构造函数，并使用构造函数参数所需的依赖项来调用它
7.4.1、编写UserService
package com.qfedu.edu.di;
public class UserService1 implements IUserService{
private IUserDAO userDAO;
private String str;
//构造方法
public UserService1(IUserDAO userDAO,String str){
this.userDAO=userDAO;
this.str=str;
}
public void print() {
System.out.println("str的值是:"+str);
userDAO.print();
}
}
7.4.2、编写描述
<!-- 接下来研究构造器注入-->
<bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
<bean id="userService1" class="com.qfedu.edu.di.UserService1">
<constructor-arg name="str" value="美女哈哈哈哈"></constructor-arg>
<constructor-arg name="userDAO" ref="userDAO"></constructor-arg>
</bean>
7.4.3、面试题
8、Spring下的自动装配(这个是给成员变量赋值最简单的一个)
8.1、编写UserService
public class UserService implements IUserService {
private IUserDAO userDAO;
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
userDAO.print();
}
}
8.2、编写描述
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd" default-autowire="byName">
<bean id="userDAO" class="com.qfedu.edu.auto.UserDAO"></bean>
<!--
autowire="byType"：这个类中的成员变量只要是有set方法 那么都会自动的去 IOC容器中去找
类型和成员变量类型一致的对象进行赋值
autowire="byName"：这个表示的意思是 下面进行初始化的时候 找到UserService中拥有set方法的成员变量
然后又去找 IOC容器 只要是这个容器中对象和名字和 成员变量的名字一致的话就会进行赋值
-->
<bean id="userService" class="com.qfedu.edu.auto.UserService" autowire="byType"></bean>
</beans>
9、Spring下的注解的使用(***)
当我们使用下面三个注解 放到类上的时候 默认情况下 这个对象的名字 就是类名的手写字母小写
下面三个注解都可以通过 value属性给这个对象取名字
@Component：表示的意思是将 所标注的类的对象放到IOC容器中去(除了业务逻辑层和DAO层之外的地方) 这个注解是下面两个注解的爹
@Service：表示的意思是将 所标注的类的对象放到IOC容器中去(这个一般用在业务逻辑层)
@Repository：表示的意思是将 所标注的类的对象放到IOC容器中去(这个一般用在DAO层)
@Autowired：先通过类型注入 如果这个类型的对象在IOC容器中有多个的话 那么再通过名字注入
@Resource：先通过名字去找这个对象 如果是没找到 那么再通过类型去找 类型找到一个直接赋值 找到多个报错
@Scope：这是这个类的对象是单例的还是多例的
@Lazy(value = true) ： 这个就表示是懒加载这个对象
@PostConstruct：这个表示的是 我们对象放到IOC容器去的时候要进行资源的初始化操作使用的注解(init-method)
@PreDestroy：这个表示的是 对象销毁的时候要进行资源回收操作 的注解(destroy-method)
package com.qfedu.edu.annotation;
@Service // userService
@Scope //这是这个类的对象是单例的还是多例的
@Lazy(value = true) //这个就表示是懒加载这个对象
public class UserService implements IUserService {
@PostConstruct
public void init(){
System.out.println("资源初始化操作");
}
// 先通过类型注入 如果这个类型的对象在IOC容器中有多个的话 那么再通过名字注入
//@Autowired
//先通过名字去找这个对象 如果是没找到 那么再通过类型去找 类型找到一个直接赋值 找到多个报错
@Resource
private IUserDAO userDAO;
public void print() {
userDAO.print();
}
@PreDestroy //这个表示的是 对象销毁的时候要进行资源回收操作 的注解
public void destory(){
System.out.println("资源回收的操作...");
}
}
在xml里配置一下包
<!--配置扫描注解的位置在哪里 -->
<context:component-scan base-package="com.qfedu.edu.annotation"/>
</beans>
10、AOP的使用
AOP是一种编程思想
就是我们在写代码的时候 会出很多重复的代码、然后我们可以将这些重复的代码 抽取到一个指定的类中去 这个类就叫做切面类(工具类) 然后在原来代码正常执行的时候 通过代理的设计模式 动态的将这些代码植入到原来的位置让原来的程序 能够正常运行的这种编程思想 就叫做 面向切面编程
10.1、手写这个AOP如何来编写
新建一个aop.sx包
注意：所有的类都要放在IOC容器中
10.1.1、编写UserService
package com.qfedu.edu.aop.sx;
public interface IUserService {
//调用DAO打印的方法
void print();
}
UserService实现类
@Service
public class UserService implements IUserService {
@Resource
private IUserDAO userDAO;
public void print() {
userDAO.print();
}
}
10.1.2、编写UserDAO
package com.qfedu.edu.aop.sx;
public interface IUserDAO {
//打印的方法
void print();
}
UserDAO实现类
package com.qfedu.edu.aop.sx;
@Repository //没给这个对象取名字呀:这个对象的名字是啥呢? ；，类名的手写字母小写 userDAO
public class UserDAO implements IUserDAO {
public void print() {
System.out.println("------------DAO执行了---------");
}
}
10.1.3、编写代理类工厂
将代理对象放入IOC容器，注意：放到IOC容器的不是这个UserServiceProxyFactoryFactoryBean类，因为实现了FactoryBean接口，所以IOC容器放的是getObject()的返回值
首先生成代理类对象 * 第一个参数是类加载器 ：固定写法 被代理的类.class.getClassLoader * 第二个参数是被代理的类实现的接口 * 1、如果被代理的是类 * 类.class.getInterfaces() * 2、如果被代理的是接口 * new Class[]{接口.class} * 第三个参数：回调函数 new InvocationHandler() * JDK代理实际上生成的是 接口的实现类 兄弟 * 在JDK代理中第三个参数是最重要的 因为可以监控方法在什么时候执行
package com.qfedu.edu.aop.sx;
@Component(value = "userServiceProxy") //取名字
public class UserServiceProxyFactoryFactoryBean implements FactoryBean<IUserService> {
@Autowired
private InvocationHandler invocationHandler;
//动态代理生成的是兄弟，所以使用爹去接收（接口）
public IUserService getObject() throws Exception {//被代理的类userService实现了接口，所以使用jdk代理，三大参数
//代理
IUserService userService= (IUserService) Proxy.newProxyInstance(UserService.class.getClassLoader(),
UserService.class.getInterfaces(),
invocationHandler);//这个单独提出来，写一个invocationHandler类
return userService;
}
public Class<?> getObjectType() {
return IUserService.class;
}
}
10.1.4、编写AOP类
package com.qfedu.edu.aop.sx;
/**
* 这个类就是咋们抽取重复代码的地方
* 我们在做开发的时候 整个的业务逻辑类 的方法执行的时候 都需要在执行之前 打开事务
* 执行完成之后 关闭和提交事务 所以打开事务 和 关闭和提交事务 是重复的 所以我们将它抽取到一个类中
* 这个类 就有一个专业的名词叫做 切面类
*/
@Component
public class TransactionAop {
public void beginTransaction(){
System.out.println("----开启事务----");
}
public void commit(){
System.out.println("----提交和关闭事务----");
}
}
10.1.5、编写测试类
bean-anno.xml
<!--扫描注解的位置 -->
<context:component-scan base-package="com.qfedu.edu.aop.sx"/>
测试
package com.qfedu.edu.aop.sx;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test01 {
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-anno.xml");
//第二步：就可以从容器中找我们需要的对象了
//注意：这里找的对象是代理对象,不是我们定义的userService对象，是爹，兄弟不能代替兄弟
IUserService userServiceProxy = (IUserService) context.getBean("userServiceProxy");
userServiceProxy.print();//这里调用的是代理对象的第三个参数，UserServiceProxyFactoryFactoryBean的第三个参数
context.stop();
context.close();
}
}
----开启事务----
----DAO执行了---------
----提交和关闭事务----
10.2、配置方式如何实现AOP
10.2.1、编写UserService
package com.qfedu.edu.aop.config;
public class UserService implements IUserService {
private IUserDAO userDAO;
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
userDAO.print();
}
}
10.2.2、编写AOP
这个AOP类中就有很多的注入时机
package com.qfedu.edu.aop.config;
//这个AOP类中就有很多的注入时机
public class Aop {
//在执行目标方法之前植入代码
public void before() {
System.out.println("--------before-------------");
}
//在执行目标方法之后 植入代码
public void after() {
System.out.println("--------after-------------");
}
//方法返回值的时候植入我们的代码
public void afterReturn() {
System.out.println("--------afterReturn-------------");
}
//抛出异常的时候植入我们的代码
public void afterThrowing() {
System.out.println("--------afterThrowing-------------");
}
/**
* 环绕植入我们的代码
*
* 环绕：
* 方法执行前
* 方法执行后
* 相当于
* before+after
*/
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//TODO 这里就是执行目标方法之前植入代码的位置
System.out.println("--------around------before-------");
Object proceed = proceedingJoinPoint.proceed();
System.out.println("--------around------after-------");
//TODO 这里就是执行完目标方法之后 植入我们的代码
return proceed;
}
}
10.2.3、编写配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">
<!--生成DAO对象-->
<bean id="userDAO" class="com.qfedu.edu.aop.config.UserDAO"></bean>
<!--生成Service对象-->
<bean id="userService" class="com.qfedu.edu.aop.config.UserService">
注入DAO
<property name="userDAO" ref="userDAO"></property>
</bean>
<!--生成AOP的对象-->
<bean id="aop" class="com.qfedu.edu.aop.config.Aop"></bean>
<!--配置aop-->
<!--打开AOP的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!--配置AOP-->
<aop:config>
<!-- 切入点表达式 代码的植入位置
id：给切入点表达式设置唯一标识
execution(语法记住
*：返回值类型不确定就写 *
com.qfedu.edu.aop.config.UserService.* ：这个表示的是这个类下面的所有的方法
com.qfedu.edu.aop.config.*.* ：这个表示的是这个包下面的所有类的所有方法
(..)：表示的是方法的参数类型不确定
-->
<aop:pointcut id="pt" expression="execution(* com.qfedu.edu.aop.config.UserService.*(..))"/>
<!--配置具体的方法，这个表示的是配置的是AOP的切面类是谁-->
<aop:aspect ref="aop">
<!--在执行目标方法之前植入的代码的方法名字是啥-->
<aop:before method="before" pointcut-ref="pt"></aop:before>
<aop:after method="after" pointcut-ref="pt"></aop:after>
<aop:after-throwing method="afterThrowing" pointcut-ref="pt"></aop:after-throwing>
<aop:around method="around" pointcut-ref="pt"></aop:around>
<aop:after-returning method="afterReturn" pointcut-ref="pt"></aop:after-returning>
</aop:aspect>
</aop:config>
</beans>
10.2.4、编写测试
package com.qfedu.edu.aop.config;
public class Test001 {
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop-config.xml");
//第二步：就可以从容器中找我们需要的对象了
IUserService userService = context.getBean(IUserService.class);
userService.print();
context.stop();
context.close();
}
}
10.3、注解模式如何实现AOP(重要)
10.3.1、编写UserService
package com.qfedu.edu.aop.anno;
@Component
public class UserService implements IUserService {
@Autowired
private IUserDAO userDAO;
//set注入
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
public void print() {
userDAO.print();
}
}
10.3.2、编写UserDAO
package com.qfedu.edu.aop.anno;
@Component
public class UserDAO implements IUserDAO {
public void print() {
System.out.println("------------DAO执行了---------");
}
}
10.3.3、编写AOP
package com.qfedu.edu.aop.anno;
/**
* 这个AOP类中就有很多的注入时机
*/
@Component
@Aspect //这个注解的意思是下面的类是切面类
public class Aop {
//定义切入点表达式的地方
@Pointcut(value = "execution(* com.qfedu.edu.aop.anno.UserService.*(..))")
public void pt(){}
//在执行目标方法之前植入代码
@Before(value = "pt()")
public void before() {
System.out.println("--------before-------------");
}
//在执行目标方法之后 植入代码
@After(value = "pt()")
public void after() {
System.out.println("--------after-------------");
}
//方法返回值的时候植入我们的代码
@AfterReturning(value = "pt()")
public void afterReturn() {
System.out.println("--------afterReturn-------------");
}
/**
* 抛出异常的时候植入我们的代码
*/
@AfterThrowing(value = "pt()")
public void afterThrowing() {
System.out.println("--------afterThrowing-------------");
}
/**
* 环绕植入我们的代码
*
* 环绕：
* 方法执行前
* 方法执行后
* 相当于
* before+after
*/
@Around(value = "pt()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//TODO 这里就是执行目标方法之前植入代码的位置
System.out.println("--------around------before-------");
Object proceed = proceedingJoinPoint.proceed();
System.out.println("--------around------after-------");
//TODO 这里就是执行完目标方法之后 植入我们的代码
return proceed;
}
}
10.3.4、编写配置文件
bean-aop-anno.xml
<!--扫描注解的位置-->
<context:component-scan base-package="com.qfedu.edu.aop.anno"></context:component-scan>
<!--配置AOP的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
10.3.5、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop-anno.xml");
//第二步：就可以从容器中找我们需要的对象了
IUserService userService = context.getBean(IUserService.class);
userService.print();
context.stop();
context.close();
}
10.3.6、AOP究竟可以使用在哪里呢
用户的行为记录
风险控制
微服务的统一结果集返回
- 日志记录
使用AOP，可以在不修改具体业务代码的情况下，为需要记录日志的方法添加日志记录功能。这样，当方法被调用时，日志记录逻辑会自动执行，无需在每个方法中重复编写日志记录代码。
- 事务管理
使用AOP，可以在方法执行前后自动开启和提交事务，或者在方法抛出异常时自动回滚事务。这样，开发者就无需在每个事务操作的方法中编写重复的事务管理代码。
- 安全控制
使用AOP，可以在方法执行前后进行安全检查，如权限验证、角色验证等。这样，可以确保只有具有相应权限的用户才能访问特定的方法或资源。
- 性能监控
使用AOP，可以在方法执行前后记录时间戳，以计算方法的执行时间。这样，开发者就可以了解哪些方法执行时间较长，从而有针对性地进行优化。
- 缓存处理
使用AOP，可以在方法执行前后自动检查缓存，如果缓存中存在所需数据，则直接返回缓存中的数据，无需执行实际的方法逻辑。这样可以大大减少数据库访问次数，提高应用程序的响应速度。
- 异常处理
使用AOP，可以在方法抛出异常时自动捕获异常，并执行相应的异常处理逻辑。这样，开发者就可以在不修改具体业务代码的情况下，为整个应用程序提供统一的异常处理机制。
11、DAO模块的应用(不用掌握是为了后面讲事务的时候使用)
11.1、导包
<!-- 访问数据库导包-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.18</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
11.2、编写配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!--驱动的名字-->
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<!--URL地址的使用-->
<property name="url" value="jdbc:mysql:///cd-fy-2401?useUnicode=true&characterEncoding=utf-8"></property>
<!--用户名-->
<property name="username" value="root"></property>
<!--密码-->
<property name="password" value="root"></property>
</bean>
<!--配置操作数据库的对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入咋们的数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置一个扫描-->
<context:component-scan base-package="com.qfedu.edu.dao"></context:component-scan>
</beans>
11.3、编写DAO
DAO层使用jdbcTemplate处理
@Component
public class UserDAO{
@Autowired
private JdbcTemplate jdbcTemplate;
public void insert() {
jdbcTemplate.update("insert into t_user(username,password) values(?,?)", "中国好", "中国好");
}
}
11.4、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-dao.xml");
//第二步：就可以从容器中找我们需要的对象了
UserDAO userDAO = context.getBean(UserDAO.class);
userDAO.insert();
context.stop();
context.close();
}
12、事务的使用
12.1、配置方式来实现事务
12.1.1、编写UserService类
@Service
public class UserService {
@Autowired
private UserDAO userDAO;
/**
* 这里主要测试事务
*/
public void testTX() {
userDAO.insert();
int k=1/0;
userDAO.update();
}
}
12.1.2、编写UserDAO类
@Component
public class UserDAO{
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 插入数据
*/
public void insert() {
jdbcTemplate.update("insert into t_user(username,password) values(?,?)", "中国好", "中国好");
}
/**
* 更新数据
*/
public void update() {
jdbcTemplate.update("update t_user set username=? where userId=?","666",19);
}
}
12.1.3、编写配置
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 驱动的名字-->
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<!-- URL地址的使用-->
<property name="url" value="jdbc:mysql:///cd-fy-2401?useUnicode=true&characterEncoding=utf-8"></property>
<!-- 用户名-->
<property name="username" value="root"></property>
<!--密码-->
<property name="password" value="root"></property>
</bean>
<!-- 配置操作数据库的对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 注入咋们的数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务增强-->
<tx:advice id="tx-advice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 在事务的范围内 所有的方法 事务类型都是 读写事务-->
<tx:method name="*" read-only="false"/>
</tx:attributes>
</tx:advice>
<!-- 配置aop-->
<aop:config>
<!-- 配置的是事务的应用地点-->
<aop:pointcut id="pt" expression="execution(* com.qfedu.edu.tx.config.UserService.*(..))"/>
<!-- 配置的事应用事务增强-->
<aop:advisor advice-ref="tx-advice" pointcut-ref="pt"></aop:advisor>
</aop:config>
<!-- 这里还需要配置一个AOP的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!-- 配置一个扫描-->
<context:component-scan base-package="com.qfedu.edu.tx.config"></context:component-scan>
</beans>
12.1.4、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-tx-config.xml");
//第二步：就可以从容器中找我们需要的对象了
UserService userService = (UserService) context.getBean("userService");
userService.testTX();
context.stop();
context.close();
}
}
12.2、通过注解的方式来实现事务
12.2.1、编写UserService
package com.qfedu.edu.tx.anno;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author xiaobobo
* @title: UserService
* @projectName cd-java-fy-2401-framwork-demo
* @description: TODO
* @date 2024/9/5 14:17
*/
@Service
//@Transactional //表示的是这个类中所有的方法都有事务的加持
public class UserService {
@Autowired
private UserDAO userDAO;
@Autowired
private DeptService deptService;
/**
* 这里主要测试事务
* rollbackFor = Exception.class：只要抛出异常 那么都要进行回滚
* isolation = Isolation.DEFAULT：在这里还可以设置 事务的隔离级别
* timeout = 5000：事务的超时时间
* noRollbackFor = ArithmeticException.class：什么异常不回滚
* propagation = Propagation.REQUIRES_NEW：表示的是多个事务
* propagation = Propagation.REQUIRED：这个就表示的是一个事务
*
*/
@Transactional(
rollbackFor = Exception.class,
isolation = Isolation.DEFAULT,
timeout = 5000,
propagation = Propagation.REQUIRED) //表示的是当前的方法需要事务的加持
public void testTX() {
userDAO.insert();
deptService.update();
int k = 1 / 0;
}
}
12.2.2、编写DeptService
package com.qfedu.edu.tx.anno;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author xiaobobo
* @title: DeptService
* @projectName cd-java-fy-2401-framwork-demo
* @description: TODO
* @date 2024/9/5 14:41
*/
@Service
public class DeptService {
@Autowired
private DeptDAO deptDAO;
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void update() {
deptDAO.update();
}
}
12.2.3、编写UserDAO
package com.qfedu.edu.tx.anno;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
/**
* @author xiaobobo
* @title: UserDAO
* @projectName cd-java-fy-2401-framwork-demo
* @description: TODO
* @date 2024/9/4 15:38
*/
@Component
public class UserDAO{
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 插入数据
*/
public void insert() {
jdbcTemplate.update("insert into t_user(username,password) values(?,?)", "中国好", "中国好");
}
/**
* 更新数据
*/
public void update() {
jdbcTemplate.update("update t_user set username=? where userId=?","666",19);
}
}
12.2.4、编写DeptDAO
@Repository
public class DeptDAO {
@Autowired
private JdbcTemplate jdbcTemplate;
public void update(){
jdbcTemplate.update(
"update t_dept set deptName=?",
"修改后的用户名"
);
}
}
12.2.5、编写xml
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 驱动的名字-->
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<!-- URL地址的使用-->
<property name="url" value="jdbc:mysql:///cd-fy-2401?useUnicode=true&characterEncoding=utf-8"></property>
<!-- 用户名-->
<property name="username" value="root"></property>
<!--密码-->
<property name="password" value="root"></property>
</bean>
<!-- 配置操作数据库的对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 注入咋们的数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
<!-- 这里还需要配置一个AOP的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!-- 配置一个扫描-->
<context:component-scan base-package="com.qfedu.edu.tx.anno"></context:component-scan>
</beans>
12.2.6、编写测试
public static void main(String[] args) {
//第一步：初始化这个IOC容器(这个IOC容器 就是用来装 Spring帮我们创建好的Java对象的集合)
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-tx-anno.xml");
//第二步：就可以从容器中找我们需要的对象了
UserService userService = (UserService) context.getBean("userService");
userService.testTX();
context.stop();
context.close();
}
13、通过Java代码来编写配置文件(超级重要)
在Spring1.x的时代、这个时候 所有的配置文件都是通过xml来编写的 这个时候注解还未出现
在Spring2.x的时代 这个时候 就出现了注解 这个时候就流行使用 注解来代替配置 简化配置文件的编写
在Spring3.x的时代 这个时候 就出现了 Java代码编写配置的问题
而且我们后期学习的SpringBoot的所有配置文件均是由Java编写配置的
AppConfig
这个就是替代以前的 bean-x.xml的
package com.qfedu.edu.config;
/**
* 这个就是替代以前的 bean-x.xml的
*/
@Configuration //就表示的是这个类是一个配置文件
@ComponentScan(basePackages = {"com.qfedu.edu.config"}) //这个就是Spring中的注解扫描
@PropertySource(value = "classpath:db.properties") //这个就可以引入外部的properties文件
@ImportResource(value = "classpath:bean-config.xml") //导入bean-config.xml文件
public class AppConfig {
@Value("${driverClassName}")
private String driverClassName;
@Value("${url}") //获取键值对
private String url;
@Value("${username1}")//注意：username是关键字，会起冲突，所以使用username1
private String username;
@Value("${password}")
private String password;
/**
* 表示的是将下面方法的返回值 放到IOC容器中去
* 方法的名字 就是这个对象在 IOC容器中的名字
*/
@Bean
@Scope(value = "singleton") //是否单例注解
@Lazy //是否懒加载
public IUserDAO userDAO(JdbcTemplate jdbcTemplate) {
UserDAO userDAO = new UserDAO();
userDAO.setJdbcTemplate(jdbcTemplate);
return userDAO;
}
@Bean(initMethod = "init") //对象放到IOC容器去之后 需要回调的方法是啥
public UserService userService(IUserDAO userDAO) {
UserService userService = new UserService();
userService.setUserDAO(userDAO);
return userService;
}
//配置datasource，放入IOC容器中
@Bean
public DruidDataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driverClassName);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
//@ImportResource(value = "classpath:bean-config.xml")
//当JdbcTemplate放在了xml文件，就使用上面的注解来导入
/*
@Bean
public JdbcTemplate jdbcTemplate(DruidDataSource dataSource){
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}*/
}