Spring学习
1、简介
Spring框架是一个开放源代码的J2EE应用程序框架,是针对bean的生命周期进行管理的轻量级容器。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题,提供了功能强大IOC、AOP及Web MVC等功能。
Spring框架主要由七部分组成,分别是 Spring Core(核心容器)、 Spring AOP(面向切面编程)、 Spring ORM(对象关系映射)、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。
Spring框架即以interface21框架为基础,于2004年3月24日,发布了1.0正式版。
理念:使现有技术更加容易实现,整合了现有的技术框架。
**SSH:**Struct2 + Spring + Hibernate
**SSM:**SpringMvc + Spring + Mybatiss
1.1、优点
- Spring是一个开源的免费的框架
- Spring是一个轻量级的、非入侵式的框架
- 控制反转(IOC)、面向切面编程(AOP)
- 支持事务的处理,对框架整合的支持
1.2、拓展
- SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
- SpringCloud
- SpringCloud是基于SpringBoot实现的
1.3、IOC本质
控制翻转IOC,是一种设计思想,DI(依赖注入)是实现IOC的一种方法,所谓控制反转就是:将对象的创建转移给第三方,即获得依赖对象的方式反转了。
IOC是Spring框架的核心内容,使用多种方式完美的实现了IOC,可以使用XML配置,也可以使用注解,新版本的Spring也可以零配置实现IOC。
Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用时再从IOC容器中取出需要的对象。
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入
2、HelloSpring
-
导包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.20</version> </dependency>
-
编写实体类
package com.sanmu.pojo; /** * Author:三木 * Date:2022-06-07 14:49 * Description:<描述> */ public class Hello { private String str; public String getStr() { return str; } public void setStr(String str) { this.str = str; } @Override public String toString() { return "Hello{" + "str='" + str + '\'' + '}'; } }
-
编写spring配置文件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"> <!--使用Spring来创建对象,在Spring这些都称为Bean id 相当于 变量名 class 相当于 new的对象 property 相当于给对象中的属性设置一个值 ref:引用Spring容器中创建好的对象 --> <bean id="hello" class="com.sanmu.pojo.Hello"> <property name="str" value="hello spring"/> </bean> </beans>
-
测试
import com.sanmu.pojo.Hello; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * Author:三木 * Date:2022-06-07 14:59 * Description:<描述> */ public class Mytest { public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml"); Hello hello = (Hello) context.getBean("hello"); System.out.println(hello); } }
3、IOC创建对象的方式
-
使用无参构造创建对象,默认
-
使用有参构造创建对象,有三种方式
-
下标赋值
<!--第一种方式,下标赋值--> <bean id="user" class="com.sanmu.pojo.User"> <constructor-arg index="0" value="三木"/> </bean>
-
通过类型创建,不建议使用
<!--第二种方式,通过类型创建,不建议使用--> <bean id="user" class="com.sanmu.pojo.User"> <constructor-arg type="java.lang.String" value="三木"/> </bean>
-
直接通过参数名设置
<!--第三种方式,直接通过参数名设置--> <bean id="user" class="com.sanmu.pojo.User"> <constructor-arg name="name" value="三木"/> </bean>
-
**总结:**在配置文件的时候,容器中管理的对象就已经初始化了。
4、Spring配置
4.1、alias–别名
<bean id="user" class="com.sanmu.pojo.User">
<constructor-arg name="name" value="三木"/>
</bean>
<!-- 别名,如果添加了别名,也可以使用别名获取到对象-->
<alias name="user" alias="user2"/>
4.2、bean的配置
<!--使用Spring来创建对象,在Spring这些都称为Bean
id 相当于 变量名 bean的唯一标识符
class 相当于 new的对象
name 别名,可以取多个
property 相当于给对象中的属性设置一个值
ref:引用Spring容器中创建好的对象
value:值
-->
<bean id="user" class="com.sanmu.pojo.User" name="user2,user3">
<constructor-arg name="name" value="三木"/>
</bean>
4.3、import
这个import,一般用于团队开发使用,可以将多个配置文件导入合并为一个。最后使用总配置即可
<?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>
5、依赖注入
5.1、构造器注入
5.2、Set方式注入【重点】
- 依赖注入,set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象的所有属性由容器注入
实例
-
编写实体类
package com.sanmu.pojo; /** * Author:三木 * Date:2022-06-07 16:43 * Description:<描述> */ 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 + '\'' + '}'; } }
package com.sanmu.pojo; import java.util.*; /** * Author:三木 * Date:2022-06-07 16:43 * Description:<描述> */ public class Student { private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String ,String> cards; private Set<String> games; private String wife; private Properties info; public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public String[] getBooks() { return books; } public void setBooks(String[] books) { this.books = books; } public List<String> getHobbys() { return hobbys; } public void setHobbys(List<String> hobbys) { this.hobbys = hobbys; } public Map<String, String> getCards() { return cards; } public void setCards(Map<String, String> cards) { this.cards = cards; } public Set<String> getGames() { return games; } public void setGames(Set<String> games) { this.games = games; } public String getWife() { return wife; } public void setWife(String wife) { this.wife = wife; } public Properties getInfo() { return info; } public void setInfo(Properties info) { this.info = info; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", address=" + address.toString() + ", books=" + Arrays.toString(books) + ", hobbys=" + hobbys + ", cards=" + cards + ", games=" + games + ", wife='" + wife + '\'' + ", info=" + info + '}'; } }
-
编写配置文件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"> <bean id="address" class="com.sanmu.pojo.Address"> <property name="address" value="武汉"/> </bean> <bean id="student" class="com.sanmu.pojo.Student"> <!--普通值注入,value--> <property name="name" value="三木"/> <!--Bean注入,ref--> <property name="address" ref="address"/> <!--数组注入,array--> <property name="books"> <array> <value>红楼梦</value> <value>水浒传</value> <value>三国演义</value> <value>西游记</value> </array> </property> <!--list注入,list--> <property name="hobbys"> <list> <value>听歌</value> <value>看电影</value> <value>足球</value> </list> </property> <!--map注入,map--> <property name="cards"> <map> <entry key="1" value="10001"></entry> <entry key="2" value="10002"></entry> <entry key="3" value="10003"></entry> </map> </property> <!--Set注入,set--> <property name="games"> <set> <value>英雄联盟</value> <value>王者荣耀</value> <value>原神</value> </set> </property> <!--null注入,null--> <property name="wife"> <null/> </property> <!--Properties注入,props--> <property name="info"> <props> <prop key="学号">20001</prop> <prop key="姓名">三木</prop> <prop key="性别">男</prop> </props> </property> </bean> </beans>
-
测试
import com.sanmu.pojo.Student; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * Author:三木 * Date:2022-06-07 16:56 * Description:<描述> */ public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); Student student = (Student) context.getBean("student"); System.out.println(student.toString()); } }
5.3、拓展方式注入
-
p、c命名空间注入
<?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.sanmu.pojo.User" p:name="三木" p:age="16"/> <!-- c命名空间注入,通过构造器注入,constructor-arg--> <bean id="user2" class="com.sanmu.pojo.User" c:name="木木" c:age="20"/> </beans>
注意点:p命名和c命名不能随便使用,需要导入xml约束
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
User user= (User) context.getBean("user");
System.out.println(user.toString());
}
}
5.4、bean的作用域
<!--scope属性有6个-->
<bean id="user" class="com.sanmu.pojo.User" c:name="木木" c:age="20" scope="singleton"/>
-
单例模式(singletion) Spring默认机制,公用一个对象
User user= (User) context.getBean("user"); User user2 = (User) context.getBean("user"); System.out.println(user==user2);//true
-
原型模式(prototype) 每次从容器中get的时候,都会产生一个新的对象
User user= (User) context.getBean("user");
User user2 = (User) context.getBean("user");
System.out.println(user==user2);//false
- 请求(requst)、会议(session)、应用(application)、(websocket),这些只能在web开发中使用
6、Bean的自动装配
自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找,并自动给bean装配属性
三种自动装配方式:
-
在xml中显示的配置
<bean id="user" class="com.sanmu.pojo.User" c:name="木木" c:age="20"/>
-
在Java中显示的配置
-
隐式的自动装配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: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">
<bean id="cat" class="com.sanmu.pojo.Cat"/>
<bean id="dog" class="com.sanmu.pojo.Dog"/>
<!--autowire自动装配
byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id
byType:会自动在容器上下文中查找,和自己对象属性相同的bean
-->
<bean id="people" class="com.sanmu.pojo.People" autowire="byType">
<property name="name" value="sanmu"/>
</bean>
</beans>
import com.sanmu.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Author:三木
* Date:2022-07-11 11:37
* Description:<描述>
*/
public class Mytest {
@Test
public void test1(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
People people = context.getBean("people",People.class);
people.getCat().shut();
people.getDog().shut();
}
}
总结:
- byName的时候,需要保证所有bean的 id 唯一,并且这个bean需要和自动配置的属性的set方法的值一致
- byType的时候,需要保证所有bean的 class 唯一,并且这个bean需要和自动注入的属性的类型一致
6.1、使用注解实现自动装配
要使用注解须知:
- 导入约束:
xmlns:context="http://www.springframework.org/schema/context"
- 配置注解的支持:
<context:annotation-config/>
<?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:annotation-config/>
</beans>
@Autowired
直接在属性上使用即可,也可以在set方式上使用;使用@Autowired可以不用编写Set方法。前提是自动装配的属性在IOC容器中存在。
可以使用@Qualifier(value = “xxx”)配合@Autowired使用,指定一个唯一的bean对象注入。
@Nullable 字段标记了这个注解,说明这个字段可以为Null
@Autowired和@Resource的区别:
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过byType的方式实现,而且必须要求这个对象存在。
- @Resource默认通过byname的方式实现,如果找不到名字,则通过byType实现。都找不到就报错。
7、使用注解开发
在Spring4之后,要使用注解开发,必须要保证AOP的包导入
使用注解需要导入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.sanmu.pojo"/>
<context:annotation-config/>
</beans>
@Component
组件,放在类上,说明这个类被Spring管理了,等价于
package com.sanmu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* Author:三木
* Date:2022-08-01 15:20
* Description:<描述>
*/
//等价于 <bean id="user" class="com.sanmu.pojo.User"/>
@Component
public class User{
//属性注入
@Value("sanmu")
public String name;
}
@Component的衍生注解,在web开发中,会按照mvc三层架构分层
- dao层【@Repository】
- service层【@Service】
- controller层【@Controller】
这四个注解功能都是一样的,都是代表将某个类注册到Spring容器中,装配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: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.sanmu"/>
<context:annotation-config/>
</beans>
**@Scope:**作用域,可以设置为单例模式、原型模式等等
小结
- 配置文件xml更加万能,适用于任何场合!维护简单方便
- 注解 不是自己的类不能使用,维护相对复杂
- xml用来管理bean
- 注解只负责完成属性的注入
注意:必须让注解生效,就需要开启注解的支持
8、使用Java的方式配置Spring
可以完全不使用Spring的xml配置,全权交给Java来做
JavaConfig是Spring的一个子项目,在Spring4之后,成为了一个核心功能
package com.sanmu.config;
import com.sanmu.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
/**
* Author:三木
* Date:2022-08-01 16:12
* Description:<使用Java配置类>
*/
//@Configuration代表这是一个配置类,相当于beans.xml
@Configuration
@ComponentScan("com.sanmu.pojo")
@Import(MyConfig2.class)//引入
public class MyConfig {
//注册一个bean,相当于bean标签
//id=方法名,class=方法返回值
@Bean
public User getUser(){
return new User();
}
}
package com.sanmu.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* Author:三木
* Date:2022-08-01 16:10
* Description:<实体类>
*/
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("sanmu")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
import com.sanmu.config.MyConfig;
import com.sanmu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* Author:三木
* Date:2022-08-01 16:14
* Description:<测试类>
*/
public class MyTest {
public static void main(String[] args) {
//如果完全使用配置类方式,只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User getUser = (User) context.getBean("getUser");
System.out.println(getUser.getName());
}
}
9、代理模式(proxy pattern)–AOP的底层原理
一个类代表另一个类的功能,为其他对象提供一种代理以控制对这个对象的访问。
角色分析:
- 抽象角色:一般使用接口或抽象类
- 真实角色:被代理的角色
- 代理角色:代理真实角色。一般会进行一些附属操作
- 客户:访问代理对象的人
优点:职责清晰、高扩展性、智能化
缺点:
- 增加了代理对象,因此可能会造成请求的速度变慢
- 实现代理模式需要额外的工作,有些代理模式的实现非常复杂
9.1、静态代理模式
由程序员创建代理类或特定工具自动生成源代码再对其编译,在程序运行前代理类的.class文件就已经存在
9.2、动态代理模式
在程序运行时,运用反射机制动态创建而成
动态代理分为两大类:
- 基于接口:JDK 动态代理
- 基于类:cglib
- Java字节码实现:Javasist
需要了解两个类:Proxy(代理)、 InvocationHandler(调用处理程序)
package com.sanmu.demo02;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* Author:三木
* Date:2022-08-06 15:32
* Description:<动态代理>
*/
public class ProxyIh implements InvocationHandler {
//被代理的接口
private Object target;
public void setImage(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
//处理代理实例,并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(target, args);
return result;
}
}
10、AOP(Aspect Oriented Programming)
10.1、什么是AOP
AOP:面向切面编程。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发的一个热点,也是spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度低,提高程序的可重用性,同时提高了开发的效率。
10.2、AOP在Spring中的作用
提供声明式事务;允许用户定义切面
- 横切关注点:跨越应用程序多个模块的方法或功能。即,与业务逻辑无关的,但是依旧需要关注的部分,就是横切关注点。如日志、安全、缓存、事务等
- 切面(Aspect):横切关注点被模块化的特殊对象。即,它是一个类
- 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法
- 目标(Target):被通知对象
- 代理(Proxy):向目标对象应用通知之后创建的对象
- 切入点(PointCut):切面通知执行的 ”地点“ 的定义
- 连接点(JointPoint):与切入点匹配的执行点
10.3、使用Spring实现AOP
导入AOP依赖包
<dependencies>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
</dependencies>
方式一:使用原生Spring API接口
-
创建业务接口
package com.sanmu.service; /** * Author:三木 * Date:2022-08-08 10:37 * Description:<业务代码> */ public interface UserService { public void add(); public void delete(); public void update(); public void select(); }
-
编写实现类
package com.sanmu.service; /** * Author:三木 * Date:2022-08-08 10:40 * Description:<业务实现类> */ public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加了一个用户"); } @Override public void delete() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void select() { System.out.println("查询了一个用户"); } }
-
编写前置日志类log
package com.sanmu.log; import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; /** * Author:三木 * Date:2022-08-08 11:12 * Description:<日志功能> */ public class log implements MethodBeforeAdvice { //method;要执行的目标对象的方法 //args:参数 //target:目标对象 @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了"); } }
-
编写后置日志类afterlog
package com.sanmu.log; import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; /** * Author:三木 * Date:2022-08-08 11:15 * Description:<后置日志> */ public class Affterlog implements AfterReturningAdvice { //returnValue:返回值 @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了"+method.getName()+"方法,返回结果为:"+returnValue); } }
-
配置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" 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.sanmu.service.UserServiceImpl"/> <bean id="log" class="com.sanmu.log.log"/> <bean id="afterlog" class="com.sanmu.log.Affterlog"/> <!--方式一:使用原生Spring API接口--> <!--配置AOP:需要导入AOP约束--> <aop:config> <!--切入点:expression 表达式,expression(要执行的位置:* * * *) --> <aop:pointcut id="pointcut" expression="execution(* com.sanmu.service.UserServiceImpl.*(..))"/> <!--执行环绕增加--> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/> </aop:config> </beans>
-
编写测试类
import com.sanmu.service.UserService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * Author:三木 * Date:2022-08-08 11:25 * Description:<aop测试类> */ public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml"); //动态代理的是接口 UserService userservice = (UserService) context.getBean("userservice"); userservice.add(); } }
方式二:自定义类实现AOP
-
编写自定义类
package com.sanmu.diy; /** * Author:三木 * Date:2022-08-08 14:15 * Description:<自定义类实现AOP> */ public class DiyPointcut { public void before(){ System.out.println("======方法执行前======"); } public void after(){ System.out.println("======方法执行后======"); } }
-
配置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" 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.sanmu.service.UserServiceImpl"/> <bean id="log" class="com.sanmu.log.log"/> <bean id="afterlog" class="com.sanmu.log.Affterlog"/> <!--方式二:自定义类 --> <bean id="diy" class="com.sanmu.diy.DiyPointcut"/> <aop:config> <!-- 自定义切面,ref=要引用的类--> <aop:aspect ref="diy"> <!-- 切入点--> <aop:pointcut id="point" expression="execution(* com.sanmu.service.UserServiceImpl.*(..))"/> <!-- 通知--> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config> </beans>
-
其他不变
方式三:使用注解实AOP
-
编写自定义类
package com.sanmu.diy; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; /** * Author:三木 * Date:2022-08-08 15:00 * Description:<使用注解实现AOP> */ //标注这个类是一个切面 @Aspect public class AnnotationPointCut { @Before("execution(* com.sanmu.service.UserServiceImpl.*(..))") public void before(){ System.out.println("======方法执行前======"); } @After("execution(* com.sanmu.service.UserServiceImpl.*(..))") public void after(){ System.out.println("======方法执行后======"); } @Around("execution(* com.sanmu.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint jp) throws Throwable { System.out.println("环绕前"); Signature signature = jp.getSignature();//获得签名 System.out.println("signature"+signature); Object proceed = jp.proceed();//执行方法 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.sanmu.service.UserServiceImpl"/> <bean id="log" class="com.sanmu.log.log"/> <bean id="afterlog" class="com.sanmu.log.Affterlog"/> <!-- 方式三:使用注解--> <bean id="apc" class="com.sanmu.diy.AnnotationPointCut"/> <!--开启注解支持 JDK(默认proxy-target-class="false") cglib(proxy-target-class="true") --> <aop:aspectj-autoproxy proxy-target-class="false"/> </beans>
-
其他不变
11、整合Mybatis
步骤:
-
导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop
- mybatis-spring
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.20</version> </dependency> <!-- spring操作数据库,需要一个spring-jdbc--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.20</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency> </dependencies>
-
编写配置文件
-
测试
遇到的问题:Error creating document instance UTF-8字节无效,将UTF-8改为UTF8
11.1、Mybatis-Spring
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中,创建映射器 mapper 和 SqlSession 并注入到 bean 中,以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终,可以做到应用代码不依赖于 MyBatis,Spring 或 MyBatis-Spring。
开发步骤
- 编写数据源配置
- 编写SqlSessionFactory
- 编写SqlSessionTemplate
- 编写UserMapper实现类,并注入
- 测试
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">
<!--DataSource:使用Spring的数据源代替Mybatis的配置-->
<!--class:使用spring提供的jdbc org.springframework.jdbc.datasource-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://192.168.171.3:3306/mybatis?useSSL=true &useUnicode=ture & characterEncoding=utf8 & useSSL=true"/>
<property name="username" value="sanmu"/>
<property name="password" value="123456"/>
</bean>
<!--SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!-- 可选,绑定Mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/sanmu/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是之前使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory,因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
spring-dao.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="applicationContext.xml"/>
<bean id="userMapper" class="com.sanmu.mapper.UserMapperImpl">
<property name="sqlSessionTemplate" ref="sqlSession"/>
</bean>
</beans>
UserMapperImpl.java
package com.sanmu.mapper;
import com.sanmu.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
/**
* Author:三木
* Date:2022-08-09 16:40
* Description:<UserMapper实现类>
*/
public class UserMapperImpl implements UserMapper{
private SqlSessionTemplate sqlSessionTemplate;
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
@Override
public List<User> selectUser() {
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
import com.sanmu.mapper.UserMapper;
import com.sanmu.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
/**
* Author:三木
* Date:2022-08-08 16:29
* Description:<测试类>
*/
public class MyTest {
@Test
public void test() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
12、声明式事务
12.1、回顾事务
- 把一组业务当成一个业务来做,要么都成功,要么都失败
- 事务在项目开发中十分重要,涉及到数据的一致性问题
- 确保完整性和一致性
事务ACID原则:
- 原子性
- 一致性
- 隔离性:多个业务可能操作同一个资源,防止数据损坏
- 持久性:事务一旦提交,无论发生什么问题,结果不会被影响
12.2、Spring中的事务
- 声明式事务:AOP
- 编程式事务:需要在代码中进行事务管理
实例:
-
导入需要的包
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.20</version> </dependency> <!-- spring操作数据库,需要一个spring-jdbc--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.20</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.9.1</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency> <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> <scope>provided</scope> </dependency> </dependencies>
-
编写实体类
package com.sanmu.pojo; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; /** * Author:三木 * Date:2022-08-08 16:06 * Description:<实体类> */ @Data @AllArgsConstructor @NoArgsConstructor public class User { private int id; private String username; private String pwd; }
-
编写mapper接口
package com.sanmu.mapper; import com.sanmu.pojo.User; import java.util.List; /** * Author:三木 * Date:2022-08-08 16:44 * Description:<mapper接口> */ public interface UserMapper { List<User> selectUser(); int add(User user); int delete(int id); }
-
编写实现类UserMapperImpl
package com.sanmu.mapper; import com.sanmu.pojo.User; import org.mybatis.spring.SqlSessionTemplate; import org.mybatis.spring.support.SqlSessionDaoSupport; import java.util.List; /** * Author:三木 * Date:2022-08-09 16:40 * Description:<mapper实现类> */ public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{ @Override public List<User> selectUser() { User user = new User(4, "小明", "3232323"); UserMapper mapper = getSqlSession().getMapper(UserMapper.class); mapper.add(user); mapper.delete(3); return mapper.selectUser(); } @Override public int add(User user) { return getSqlSession().getMapper(UserMapper.class).add(user); } @Override public int delete(int id) { return getSqlSession().getMapper(UserMapper.class).delete(id); } }
-
编写UserMapper.xml
<?xml version="1.0" encoding="UTF8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--namespace:绑定一个mapper接口--> <mapper namespace="com.sanmu.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from mybatis.user </select> <insert id="add" parameterType="user"> insert into user(id,username,pwd) values (#{id},#{username},#{pwd}); </insert> <delete id="delete" parameterType="user"> delete from user where id=#{id}; </delete> </mapper>
-
配置spring
mybatis-config.xml
<?xml version="1.0" encoding="UTF8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <typeAliases> <package name="com.sanmu.pojo"/> </typeAliases> </configuration>
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"> <!--DataSource:使用Spring的数据源代替Mybatis的配置--> <!--class:使用spring提供的jdbc org.springframework.jdbc.datasource--> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://192.168.171.3:3306/mybatis?useSSL=true &useUnicode=ture & characterEncoding=utf8 & useSSL=true"/> <property name="username" value="sanmu"/> <property name="password" value="123456"/> </bean> <!--SqlSessionFactory --> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="datasource"/> <!-- 可选,绑定Mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/sanmu/mapper/*.xml"/> </bean> <!--SqlSessionTemplate:就是之前使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory,因为它没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> </beans>
apring-dao.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:tx="http://www.springframework.org/schema/tx" 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/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <import resource="applicationContext.xml"/> <bean id="userMapper" class="com.sanmu.mapper.UserMapperImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean> <!--配置声明式事务 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <constructor-arg ref="datasource"/> </bean> <!--结合AOP实现事务的注入--> <!-- 配置事务通知--> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!--给哪些方法配置事务--> <!--配置事务的传播性:propagation--> <tx:attributes> <tx:method name="add" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="query" read-only="true"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!--配置事务切入--> <aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.sanmu.mapper.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config> </beans>
-
测试
import com.sanmu.mapper.UserMapper; import com.sanmu.mapper.UserMapperImpl; import com.sanmu.pojo.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * Author:三木 * Date:2022-08-31 15:30 * Description:<描述> */ public class MyTest { @Test public void test1(){ ApplicationContext Context = new ClassPathXmlApplicationContext("spring-dao.xml"); UserMapper userMapper = Context.getBean("userMapper", UserMapper.class); for (User user : userMapper.selectUser()) { System.out.println(user); } } }