框架学习—Spring(自我学习用)
1、概述
Spring是一个开源的轻量级开发框架,是为了解决企业应用程序的复杂性而创建的。以 IoC(Inverse of Control,控制反转)和 AOP(Aspect Oriented Programming,面向切面编程)为内核,使用基本的 JavaBean 完成以前只可能由 EJB 完成的工作,取代了 EJB 臃肿和低效的开发模式。
2、IOC控制反转(或称DI依赖注入)
链接: link.
Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。
谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对 象的创建;谁控制谁?当然是IoC 容器控制了对象;控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等)。
为何是反转,哪些方面反转了:有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象;为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;哪些方面反转了?依赖对象的获取被反转了。
2.1、IOC思想代码引入:
dao层接口:
public interface UserDao {
void getUser();
}
dao层接口实现类1
public class UserDaoImpl implements UserDao {
public void getUser() {
System.out.println("这是UserDao第一个实现类");
}
}
dao层接口实现类2
public class UserDaoImpl2 implements UserDao {
public void getUser() {
System.out.println("我是第二个");
}
}
service层接口
public interface UserService {
void getUser();
}
service层接口实现类
public class UserServiceImpl implements UserService {
private UserDao userDao;
//利用set实现值得动态注入(关键代码)
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
测试:
public class MyTest {
@Test
public void test(){
UserService userService = new UserServiceImpl();
((UserServiceImpl) userService).setUserDao(new UserDaoImpl2());
userService.getUser();
}
}
2.2、HelloSpring
通过spring实现对象的创建、获取、管理
1、实体类
public class Hello{
private String str;
public void setStr(String str) {
this.str = str;
}
public String getStr() {
return str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用spring来创建对象,在spring中统称为Bean-->
<!--id就相当于对象名,class表示对象属于哪个类;
property 表示参数的信息,name是指对象中的哪个参数,value表示参数值-->
<bean id="hello" class="com.wl.pojo.Hello">
<property name="str" value="helloSpring"/>
</bean>
</beans>
3、测试
public class MyTest {
@Test
public void test(){
//创建Spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
//通过容器得到对象
Hello hello = (Hello) context.getBean("hello");
//调用方法
System.out.println(hello.toString());
}
}
2.3、改造第一个例子
1、配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="impl1" class="com.wl.dao.UserDaoImpl"/>
<bean id="impl2" class="com.wl.dao.UserDaoImpl2"/>
<!--此时当我们的service需要引用UserDao不同的实现类对象时,只需要改这里的配置文件,即property的ref属性-->
<bean id="serviceImpl" class="com.wl.service.UserServiceImpl">
<property name="userDao" ref="impl2"/>
</bean>
<!--注意:ref表示引用spring中创建好的对象
value 表示具体的值,基本数据类型-->
</beans>
2、测试代码
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
//就算需要不同的实现,此时代码层面也不需要任何改动
UserService serviceImpl = (UserService) context.getBean("serviceImpl");
serviceImpl.getUser();
}
3、IOC创建对象的方式
①、使用无参构造创建对象,默认方式。
②、使用有参构造创建对象,有三种方式
实体类:
public class User {
private String name;
//有参构造
public User(String name){
this.name=name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void show(){
System.out.println("name="+name);
}
}
配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--spring IOC有参构造的三种方式-->
<!--方式一:通过参数下标index -->
<!--<bean id="user" class="com.wl.pojo.User">-->
<!--<constructor-arg index="0" value="小花"/>-->
<!--</bean>-->
<!--方式二:通过参数类型type-->
<!--<bean id="user" class="com.wl.pojo.User">-->
<!--<constructor-arg type="java.lang.String" value="小花花"/>-->
<!--</bean>-->
<!--方式三:通过参数名name 一般用这个方法即可-->
<bean id="user" class="com.wl.pojo.User">
<constructor-arg name="name" value="花花"/>
</bean>
</beans>
总结:在配置文件加载的时候,spring容器中管理的对象就已经初始化了。
import的作用
可以利用import把所有的beans.xml合并为一个配置文件ApplicationContext.xml,这样在使用的时候只引用ApplicationContext.xml就行了。
ApplicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"/>
</beans>
beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.wl.pojo.User">
<constructor-arg name="name" value="花花"/>
</bean>
</beans>
public class MyTest {
@Test
public void test(){
//使用的时候只引用ApplicationContext.xml即可
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
User user = (User) context.getBean("user");
user.show();
}
}
4、DI依赖注入
链接: link.
Spring通过DI(依赖注入)实现IOC(控制反转),常用的注入方式主要有三种:构造方法注入,setter注入,基于注解的注入。
4.1、构造方法注入
保证了一些必要的属性在Bean实例化时就设置,并且确保了bean实例在实例化后就可以使用。前面的spring有参构造创建对象就是用的这种方法构造器注入:
实体类:
public class User {
private String name;
//有参构造
public User(String name){
this.name=name;
}
}
ApplicationContext.xml
<bean id="user" class="com.wl.pojo.User">
<constructor-arg name="name" value="花花"/>
</bean>
4.2、setter注入
根据property标签的name属性的值去找对应的setter方法。由于属性注入具有可选性和灵活性高的优点,是实际上最常用的注入方式。属性注入要求bean提供一个默认的构造函数,并为需要注入的属性提供对应的setter方法。spring先调用bean默认的构造函数实例化bean对象,然后通过反射机制的方法调用setter方法注入属性值。需要注意的是,如果通过set方法注入属性,那么spring会通过默认的空参构造方法来实例化对象,所以如果在类中写了一个带有参数的构造方法,一定要把空参数的构造方法写上,否则spring没有办法实例化对象,导致报错。
实体类1:
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
实体类2:这里通过lombok提供set方法
@Data
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private Properties info;
private String wife;
}
通过set方法实现不同类型属性的注入:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="com.wl.pojo.Address">
<property name="address" value="武汉"/>
</bean>
<bean id="student" class="com.wl.pojo.Student">
<!--普通值注入:value-->
<property name="name" value="小花"/>
<!--Bean注入:ref-->
<property name="address" ref="address"/>
<!--数组-->
<property name="books">
<array>
<value>红楼梦</value>
<value>水浒传</value>
<value>西游记</value>
</array>
</property>
<!-- list -->
<property name="hobbys">
<list>
<value>羽毛球</value>
<value>看电影</value>
</list>
</property>
<!-- map -->
<property name="card">
<map>
<entry key="身份证" value="123456"/>
<entry key="校园卡" value="654321"/>
</map>
</property>
<!-- Set -->
<property name="games">
<set>
<value>荒野乱斗</value>
<value>QQ飞车</value>
</set>
</property>
<!-- Properties -->
<property name="info">
<props>
<prop key="driver">mysql</prop>
<prop key="url">3306</prop>
<prop key="name">root</prop>
<prop key="password">123456</prop>
</props>
</property>
<!-- null -->
<property name="wife">
<null/>
</property>
</bean>
</beans>
4.3、通过p命名空间和c命名空间注入
实体类:
public class User {
private int id;
private String name;
//无参构造
public User() {
}
//有参构造
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
配置文件:
<?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:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- p命名空间,可以直接注入属性的值:property -->
<bean id="user" class="com.wl.pojo.User" p:name="小花" p:id="10"/>
<!-- c命名空间,通过有参构造器注入:construct-args -->
<bean id="user2" class="com.wl.pojo.User" c:name="花花" c:id="20"/>
</beans>
测试:
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//User user = context.getBean("user", User.class);
User user = context.getBean("user2", User.class);
System.out.println(user);
}
p命名空间依赖于set方法,要求要有无参构造函数;c命名空间依赖于有参构造函数。使用的时候注意要引入约束:
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
4.4、bean的作用域
①、单例模式(spring默认机制),全局只有一个对象实例
<bean id="address" class="com.wl.pojo.Address" scope="singleton">
②、原型模式:每次从容器get时,都会产生一个新的对象。
<bean id="address" class="com.wl.pojo.Address" scope="prototype">
③、其余的request、session、application,这些只能在web开发中使用到。
5、自动装配Bean
上面的方法都是通过手动的方式对bean进行装配,spring还提供了一些自动装配的方法。
5.1、通过byName和byType实现自动装配
实体类:
public class Cat {
public void shout(){
System.out.println("miao~");
}
}
public class Dog {
public void shout(){
System.out.println("wang~");
}
}
man类:拥有cat和dog类,通过lombok实现set方法
@Data
public class Man {
private Cat cat;
private Dog dog;
private String name;
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="com.wl.pojo.Cat"/>
<bean id="dog" class="com.wl.pojo.Dog"/>
<!--
自动装配的两种方式:
byName:通过属性名实现自动装配,即id的值和set方法后的值要一致(例如setDog和dog)
byType:通过属性类型实现自动装配,但不能有多个属性同属一个类型
-->
<bean id="man" class="com.wl.pojo.Man" autowire="byName">
<property name="name" value="小花"/>
</bean>
<bean id="man2" class="com.wl.pojo.Man" autowire="byType">
<property name="name" value="花花"/>
</bean>
</beans>
测试:
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
Man man = context.getBean("man", Man.class);
man.getCat().shout();
man.getDog().shout();
}
5.2、通过注解实现自动装配
通过@Autowired注解自动装配
使用方法:
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--
使用@Autowired注解进行自动装配:
首先要导入context约束
xmlns:context="http://www.springframework.org/schema/context
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
然后对自动装配进行配置
<context:annotation-config/>
-->
<context:annotation-config/>
<bean id="cat" class="com.wl.pojo.Cat"/>
<bean id="cat1" class="com.wl.pojo.Cat"/>
<bean id="dog" class="com.wl.pojo.Dog"/>
<bean id="man" class="com.wl.pojo.Man"/>
</beans>
然后在实体类属性前加上@Autowired即可
@Data
public class Man {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
测试:
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Man man = context.getBean("man", Man.class);
man.getCat().shout();
man.getDog().shout();
}
注意:@Autowired默认使用byType来装配属性,如果匹配到相同类型的多个实例,再通过byName来确定Bean。同时也可以通过@qulifier注解显示指定要使用的bean。
通过@Resource注解实现自动装配
@Resource注解是java自带的,使用方法和@Autowired类似,使用时在实体类属性前加上@Resource即可。不同的是@Resource默认使用byName来装配属性,当通过byName匹配不到时,会使用byType进行匹配。
6、使用注解开法
可以使用注解实现bean的注入,方法如下:
首先要引入context约束,指定要扫描的包
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--指定要扫描的包,这个包下的注解就会生效-->
<context:component-scan base-package="com.wl.pojo"/>
<context:annotation-config/>
</beans>
6.1、bean的注入
使用@Component注解,在要注入的实体类前加上@Component即可,
@Component //作用相当于 <bean id="user" class="com.wl.pojo.User"/>
public class User {
public String name;
}
6.2、属性的注入
使用@Value注解即可
@Component
public class User {
@Value("花花") //作用相当于 <property name="name" value="花花"/>
public String name;
}
6.3、@Component的几个衍生注解
在web开发中,会按照mvc三层架构分层,每层都有自己的注解,但其作用和@Component是一样的
dao层: @Repository
service层: @Service
controller层: @Controller
6.4、作用域
使用@Scope注解即可
@Component
@Scope("singleton")
public class User {
@Value("花花")
public String name;
}
6.5、小结
xml与注解:
xml更加万能,适用于任何场合,维护简单方便;注解 不是自己的类使用不了,维护相对复杂。一般实践会使用xml来管理bean,注解只负责完成属性的注入。
7、使用JavaConfig实现配置
也可以不使用配置文件来实现bean的注入,即依赖配置类来实现注入
使用方法如下:
1、配置类
//由@Configuration注解修饰的类也会被Spring容器托管,不同的是@Configuration代表这是一个配置类,
//其作用相当于一个applicationContext.xml配置文件
@Configuration
public class WlConfig {
//注册一个bean,就相当于applicationContext.xml中的一个bean标签
//方法名就相当于bean标签中的id属性,
//方法的返回值就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User(); //返回要注入到bean中的对象
}
}
2、实体类
@Component
public class User {
@Value("花花")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3、测试
@Test
public void test(){
//如果完全使用配置类而不依赖于配置文件,就需要使用AnnotationConfig上下文对象来获取容器,通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(WlConfig.class);
User getUser = context.getBean("getUser",User.class);
System.out.println(getUser.getName());
}
8、Spring Aop
AOP(面向切面编程),可以说是OOP( 面向对象编程)的补充和完善。
8.1、 AOP的基本概念
(1)Aspect(切面):通常是一个类,里面可以定义切入点和通知
(2)JointPoint(连接点):程序执行过程中明确的点,一般是方法的调用
(3)Advice(通知):AOP在特定的切入点上执行的增强处理,有before、after、afterReturning、afterThrowing、around
(4)Pointcut(切入点):就是带有通知的连接点,在程序中主要体现为书写切入点表达式
(5)AOP代理:AOP框架创建的对象,代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理,也可以是CGLIB代理,前者基于接口,后者基于子类
8.2、通知方法:
前置通知:在我们执行目标方法之前运行(@Before)
后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
返回通知:在我们的目标方法正常返回值后运行(@AfterReturning)
异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知(@Around)
8.3、Spring AOP的三种实现方式
方式一:使用Spring API原生接口
接口:
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
接口实现类:
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改了一个用户");
}
public void select() {
System.out.println("查询了一个用户");
}
}
需要增加的服务1:
//通过实现Spring原生接口MethodBeforeAdvice来完成在切入点之前要实现的功能
public class Log implements MethodBeforeAdvice {
/**
* @param method 要执行的目标对象的方法
* @param args 方法参数
* @param target 目标对象
* @throws Throwable
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"类的方法"+method.getName()+"执行了");
}
}
需要增加的服务2:
//通过实现Spring原生接口AfterReturningAdvice来完成在切入点之后要实现的功能
public class AfterLog implements AfterReturningAdvice {
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了"+method.getName()+"方法,返回结果为:"+returnValue);
}
}
配置文件:
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="log" class="com.wl.log.Log"/>
<bean id="afterLog" class="com.wl.log.AfterLog"/>
<bean id="userService" class="com.wl.service.UserServiceImpl"/>
<!--方式一:使用原生Spring api接口-->
<!--配置aop:需要导入aop的约束-->
<aop:config>
<!--切入点:expression:表达式,execution(要执行的位置)-->
<aop:pointcut id="pointcut" expression="execution(* com.wl.service.UserServiceImpl.*(..))"/>
<!--执行环绕增强-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
测试:
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
方式二:自定义类:
自定义一个类实现需要增加的服务
public class DiyPointCut {
public void before(){
System.out.println("=============执行方法前==============");
}
public void after(){
System.out.println("=============执行方法后===============");
}
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.wl.service.UserServiceImpl"/>
<!--方式二:自定义类-->
<bean id="diy" class="com.wl.diy.DiyPointCut"/>
<aop:config>
<!--自定义切面,ref指向要引用的类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* com.wl.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
</beans>
方式三:通过注解实现
@Aspect //标注这个类是一个切面
public class AnnoPointCut {
@Before("execution(* com.wl.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("=============执行方法前==============");
}
@After("execution(* com.wl.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("=============执行方法后===============");
}
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.wl.service.UserServiceImpl"/>
<!--方式三:通过注解实现-->
<bean id="annoPointCut" class="com.wl.diy.AnnoPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>
</beans>
9、Spring整合Mybatis
步骤:
①、配置数据源
②、配置SqlSessionFactory
③、配置SqlSessionTemplate(相当于MyBatis里的SqlSession)
④、给接口加实现类(Spring通过该实现类)
⑤、把实现类注入到Spring
⑥、测试
导入依赖:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
</dependencies>
1、spring-dao.xml,该配置文件用于在Spring中进行MyBatis的相关配置
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--数据源DataSource: 使用Spring的数据源替换MyBatis的配置-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!--sqlSessionFactory配置-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--绑定MyBatis配置文件-->
<property name="configLocation" value="mybatis-config.xml"/>
<!--绑定mapper-->
<property name="mapperLocations" value="classpath:com/wl/mapper/*.xml"/>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造函数注入sqlSessionFactory,因为它没有Set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
```xml
此时的mybatis-config.xml 配置文件只保留一些辅助配置,其他的数据源、mapper之类的主要配置一般会在spring-dao.xml中进行整合
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.wl.pojo"/>
</typeAliases>
</configuration>
2、编写接口实现类
pojo:
@Data
public class User {
private int id;
private String name;
private String pwd;
}
接口:
public interface UserMapper {
public List<User> selectUsers();
}
接口实现类:Spring通过该类实现对Mybatis的管理
public class UserMapperImpl implements UserMapper {
private SqlSessionTemplate sqlSession;
//通过set方法实现SqlSessionTemplate的注入
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
public List<User> selectUsers() {
return sqlSession.getMapper(UserMapper.class).selectUsers();
}
}
mapper.xml文件:
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wl.mapper.UserMapper">
<select id="selectUsers" resultType="user">
select * from mybatis.user;
</select>
</mapper>
3、applicationContext.xml,用于整合其他的配置文件,自己编写的实体类的bean注入一般在这个配置文件中实现
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.wl.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
4、测试:
@Test
public void test(){
//此时我们就可以通过Spring实现MyBatis的功能
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper bean = context.getBean("userMapper",UserMapper.class);
List<User> users = bean.selectUsers();
for (User user : users) {
System.out.println(user);
}
}
10、Spring声明式事务
在Spring中实现对数据库事物,首先需要在spring-dao.xml中配置对事务的支持,然后可以采取AOP的方式实现事务的织入
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg name="dataSource" ref="dataSource" />
</bean>
<!--结合AOP实现事物的织入-->
<!--配置事物的的通知advice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给哪些方法配置事务,并配置事物的传播特性-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" propagation="REQUIRED"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.wl.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>