02-Spring
简介
组成
拓展
spring boot
- 一个快速开发的脚手架
- 基于spring boot可以快速开发单个微服务
- 约定大于配置
spring cloud
- spring cloud是基于spring boot实现的
因为现在大多数公司都在使用spring boot进行快速开发,学习spring boot的前提,需要完全掌握spring以及springMVC。承上启下的作用
IOC理论推导
业务处理流程:
- UserDao接口
- UserDaoImpl实现类
- UserService接口
- UserServiceImpl实现类
在我们之前的业务中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改源代码。如果程序的代码量十分大,修改一次的成本代价十分昂贵。
之前,程序是主动创建对象,控制权在程序员手上,使用了set注入后,程序不再具有主动性,而是变成了被动的接收对象。这种思想从本质上解决了问题,我们程序员不用再去管理对象的创建了。系统的耦合性大大降低。
本质
控制反战IOC(Inversion of Control)是一种设计思想,DI(依赖注入)实现IOC的一种方法,也有人认为DI只是IOC的另一种说法,没有IOC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候,Bean的定义信息是实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器其实现方法是依赖注入(Dependency injection)
HelloSpring
pojo
public class Spring {
private String name;
public String getName() {
return name;
}
public void setName(String name){
this.name=name;
}
@Override
public String toString() {
return "Spring{" +
"name='" + name + '\'' +
'}';
}
}
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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用Spring创建对象,在Spring中这些都称为Bean-->
<!--ref:引用Spring容器中已经创建好的对象
value:具体的值,基本数据类型-->
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring">
<property name="name" value="HelloSpring"/>
</bean>
</beans>
Mytest
public class MyTest {
@Test
public void test(){
//获取Spring的上下文对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在Spring中管理了,我们要使用,直接去里面取出来即可
Spring spring = (Spring)applicationContext.getBean("HelloSpring");
System.out.println(spring.toString());
}
}
IOC创建对象的方式
在配置文件加载的时候,容器中管理的对象就已经初始化了
-
默认使用无参构造创造对象
-
有参构造的方式:
-
下标赋值
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring"> <constructor-arg index="0" value="helloSpring"/> </bean>
-
通过类型赋值
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring"> <constructor-arg type="java.lang.String" value="helloSpring"/> </bean>
-
通过参数名来赋值
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring"> <constructor-arg name="name" value="helloSpring"/> </bean>
-
Spring配置
别名
给bean对象取别名
<alias name="HelloSpring" alias="spring"/>
Spring spring = (Spring)applicationContext.getBean("spring");
Bean的配置
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring" name="spring,spring1">
<constructor-arg name="name" value="helloSpring"/>
</bean>
- id:bean的唯一标识符,也就是相当于对象名
- class:bean对象所对应的全限定名:包名+类型
- name:也是取别名,不过可以同时取多个别名
- scope:作用域
import
一般用于团队开发使用,它可以将多个配置文件导入合并为一个
<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
DI依赖注入
构造器注入
<bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring" name="spring,spring1">
<constructor-arg name="name" value="helloSpring"/>
</bean>
Set方式注入
依赖:bean对象的创建依赖于容器
注入:bean对象中的所有属性,由容器注入
pojo
Address
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 + '\'' +
'}';
}
}
Student
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbies;
private Map<String,String> card;
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> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
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) +
", hobbies=" + hobbies +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
beans.xml
<bean id="Address" class="com.XZY_SUNSHINE.pojo.Address">
<property name="address" value="中国"/>
</bean>
<bean id="Student" class="com.XZY_SUNSHINE.pojo.Student">
<!--普通变量注入-->
<property name="name" value="XZY"/>
<!--对象注入-->
<property name="address" ref="Address"/>
<!--数组注入-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>狂飙</value>
</array>
</property>
<!--Map注入-->
<property name="card">
<map>
<entry key="二班" value="22号"/>
</map>
</property>
<!--List注入-->
<property name="hobbies">
<list>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<!--Set注入-->
<property name="games">
<set>
<value>LOL</value>
<value>LOLM</value>
<value>CF</value>
</set>
</property>
<!--Null注入-->
<property name="wife">
<null/>
</property>
<!--配置注入-->
<property name="info">
<props>
<prop key="url">男</prop>
</props>
</property>
</bean>
Test
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("Student");
System.out.println(student.toString());
}
拓展方式注入
拓展方式注入不能直接使用,需要引入约束
约束
c标签约束
xmlns:c="http://www.springframework.org/schema/c"
p标签约束
xmlns:p="http://www.springframework.org/schema/p"
使用
pojo
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
c标签用于有参构造
<bean id="User2" class="com.XZY_SUNSHINE.pojo.User" c:name="高启兰" c:age="16"/>
p标签用于无参构造
<bean id="User" class="com.XZY_SUNSHINE.pojo.User" p:age="18" p:name="高启强"/>
Bean作用域
单例模式(默认)
beans.xml
<bean id="User" class="com.XZY_SUNSHINE.pojo.User" p:age="18" p:name="高启强" scope="singleton"/>
Test
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = context.getBean("User", User.class);
User user1 = context.getBean("User", User.class);
System.out.println(user1.toString());
System.out.println(user.toString());
System.out.println(user1==user);
}
//输出
//User{name='高启强', age=18}
//User{name='高启强', age=18}
//true
原型模式
每次从容器get的时候,都会产生一个新的对象
beans.xml
<bean id="User" class="com.XZY_SUNSHINE.pojo.User" p:age="18" p:name="高启强" scope="prototype"/>
Test
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = context.getBean("User", User.class);
User user1 = context.getBean("User", User.class);
System.out.println(user1.toString());
System.out.println(user.toString());
System.out.println(user1==user);
}
//输出
//User{name='高启强', age=18}
//User{name='高启强', age=18}
//false
Bean的自动装配
- 自动装配是Spring满足Bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中的三种装配方式:
- 在xml中显式的配置
- 在Java中显式的配置
- 隐式的自动装配bean
搭建环境
pojo
//cat
public class Cat {
public void shout(){
System.out.println("miao~");
}
}
//dog
public class Dog {
public void shout(){
System.out.println("wang~");
}
}
//people
public class People {
private String name;
private Dog dog;
private Cat cat;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public People(String name, Dog dog, Cat cat) {
this.name = name;
this.dog = dog;
this.cat = cat;
}
public People() {
}
}
ByName自动装配
会自动在容器上下文中寻找和自己属性名相同的bean id
<bean id="dog" class="com.XZY_SUNSHINE.pojo.Dog"/>
<bean id="cat" class="com.XZY_SUNSHINE.pojo.Cat"/>
<bean id="people" class="com.XZY_SUNSHINE.pojo.People" autowire="byName" p:name="高启强"/>
ByType自动装配
会自动在容器上下文中查找,和自己属性类型相同的bean
<bean class="com.XZY_SUNSHINE.pojo.Dog"/>
<bean class="com.XZY_SUNSHINE.pojo.Cat"/>
<bean id="people" class="com.XZY_SUNSHINE.pojo.People" autowire="byType" p:name="高启强"/>
小结
- ByName的时候,需要保证所有bean 的id唯一,并且这个bean id需要和自动注入的属性的名字一致
- ByType的时候,需要保证所有bean 的Class唯一,并且这个bean需要和自动注入的属性的类型一致
使用注解实现自动装配
在Spring4之后,要使用注解开发,必须要保证aop的包导入
使用注解要导入context约束,增加注解的支持!
<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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
开启注解的支持
<context:annotation-config/>
直接在属性上使用或在set方式上使用@Autowired
使用@Autowired我们可以不用编写Set方法了,前提是你这个自动装配的属性在IOC(Spring)容器中存在,且符合名字byname
科普
@Nullable 字段标记了这个注解,说明这个字段可以为null
public @interface Autowired {
boolean required() default true;//如果显式的定义了这个属性为false允许值为空
}
如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候,我们可以使用@Qualifier(value=“bean id”)来辅助完成
@Autowired
@Qualifier(value = "cat")
@Reasource注解
@Resource(name = "dog")
private Dog dog;
@Reasource和@Autowired的区别
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过byname的方式实现,而且必须要求这个对象存在
- @Reasource默认通过byname的方式实现,如果找不到名字,则通过ByType实现,如果两个都找不到就报错
使用注解开发
开启扫描包选项,这个包下的注解就会生效
<context:component-scan base-package="com.XZY_SUNSHINE.pojo"/>
使用@Component注解
@Component//等价于<bean id="dog" class="com.XZY_SUNSHINE.pojo.Dog"/>
public class Dog {
public void shout(){
private String name;
System.out.println("wang~");
}
}
使用@Value注解给属性赋值
@Value("dog")//等价于<property name="name" value="dog"/>
private String name;
衍生注解
@Component有几个衍生注解,我们在web开发中,会按照MVC三层架构分层
- dao[@repository]
- service[@Service]
- controller[@Controller]
小结
xml与注解:
- xml更加万能,适用于任何场合!维护简单方便
- 注解不是自己类使用不了,维护相对复杂
xml与注解最佳实践:
- xml用来管理bean
- 注解只负责完成属性的注入
使用Java的方式配置spring
完全不用spring的xml配置,全权交给Java来做
pojo
public class User {
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
config
//代表这是一个配置类,相当于之前的beans.xml
@Configuration
//扫描包。等价于之前的<context:component-scan base-package="位置"/>
@ComponentScan("com.XZY_SUNSHINE.pojo")
//导入配置类,合并。
@Import(config2.class)
public class config {
@Bean//相当于之前的<bean id="get_user" class="com.XZY_SUNSHINE.pojo.User"/>
public User get_user(){
User user = new User();
user.setName("启强");
return user;
}
}
Test
@Test
public void Test(){
ApplicationContext context = new AnnotationConfigApplicationContext(config.class);
User user = (User) context.getBean("get_user");
System.out.println(user.toString());
}
}
代理模式
分类
- 静态代理
- 动态代理
静态代理
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理角色的人
代码步骤
抽象角色
public interface rent {
public void rent();
}
真实角色
public class host implements rent{
public void rent() {
System.out.println("房东要租房子");
}
}
代理角色
public class proxy implements rent{
private host host;
public proxy() {
}
public proxy(host host) {
this.host = host;
}
public void rent() {
this.host.rent();
seeHouse();
setContract();
fare();
}
public void seeHouse(){
System.out.println("看房子...");
}
public void setContract(){
System.out.println("签合同....");
}
public void fare(){
System.out.println("收取中介费....");
}
}
客户端访问代理角色
public class Client {
public static void main(String[] args) {
proxy proxy = new proxy(new host());
proxy.rent();
}
}
代理模式的好处:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共业务就交给代理角色,实现了业务的分工
- 公共业务发生拓展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色,代码量会翻倍,开发效率会变低
动态代理
- 动态代理和静态代理的角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口—JDK动态代理
- 基于类:cglib
- Java字节码实现:javasist
代码
proxy
public class proxy implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
Object invoke = method.invoke(target, args);
return invoke;
}
public void seeHouse(){
System.out.println("看房子....");
}
}
client
public class Client {
public static void main(String[] args) {
host host = new host();
proxy proxy = new proxy();
proxy.setTarget(host);
host.rent();
rent proxy1 = (rent) proxy.getProxy();
proxy1.rent();
}
}
好处
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共业务就交给代理角色,实现了业务的分工
- 公共业务发生拓展的时候,方便集中管理
- 一个动态代理类是一个接口,一般就是对应的一类业务
- 一个动态代理类可以代理多个类,只要是实现了同一个类
AOP
什么是AOP
AOP:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发效率
AOP在spring中的作用
提供声明式事务:允许用户自定义切面
- 横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等…
- 切面(ASPECT)︰横切关注点被模块化的特殊对象。即,它是一个类。
- 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。
- 目标(Target):被通知对象。
- 代理(Proxy)︰向目标对象应用通知之后创建的对象。
- 切入点(PointCut) :切面通知执行的“地点"的定义。
- 连接点(JointPoint) :与切入点匹配的执行点。
使用spring实现AOP
导包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.19</version>
</dependency>
pojo.userService
public interface UserService {
public void insertUser();
public void deleteUser();
public void updateUser();
public void selectUser();
}
pojo.userServiceImpl
public class userServiceImpl implements UserService{
@Override
public void insertUser() {
System.out.println("插入了一个用户");
}
@Override
public void deleteUser() {
System.out.println("删除了一个用户");
}
@Override
public void updateUser() {
System.out.println("更新了一个用户");
}
@Override
public void selectUser() {
System.out.println("查询了一个用户");
}
}
方式一
java代码
public class afterLog implements AfterReturningAdvice {
@Override
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行"+method.getName()+"之后...");
}
}
public class beforeLog implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("执行"+method.getName()+"之前...");
}
}
xml代码
<bean id="UserService" class="com.XZY_SUNSHINE.pojo.userServiceImpl"/>
<bean id="BeforeLog" class="com.XZY_SUNSHINE.log.beforeLog"/>
<bean id="AfterLog" class="com.XZY_SUNSHINE.log.afterLog"/>
<aop:config>
<aop:pointcut id="ponitCut" expression="execution(* com.XZY_SUNSHINE.pojo.userServiceImpl.*(..))"/>
<aop:advisor advice-ref="BeforeLog" pointcut-ref="ponitCut"/>
<aop:advisor advice-ref="AfterLog" pointcut-ref="ponitCut"/>
</aop:config>
方式二
java代码
public class DiyLog {
public void Before(){
System.out.println("执行方法前......");
}
public void After(){
System.out.println("执行方法后......");
}
}
xml代码
<bean id="DiyLog" class="com.XZY_SUNSHINE.Diy.DiyLog"/>
<aop:aspect ref="DiyLog">
<aop:pointcut id="ponitCut" expression="execution(* com.XZY_SUNSHINE.pojo.userServiceImpl.*(..))"/>
<aop:before method="Before" pointcut-ref="ponitCut"/>
<aop:after method="After" pointcut-ref="ponitCut"/>
</aop:aspect>
方式三
java代码
@Aspect
public class annovationLog {
@Before("execution(* com.XZY_SUNSHINE.pojo.userServiceImpl.*(..))")
public void Before(){
System.out.println("执行方法前......");
}
}
xml代码
<bean id="annovationLog" class="com.XZY_SUNSHINE.Diy.annovationLog"/>
<aop:aspectj-autoproxy/>
整合Mybatis
导包
- junit
- mysql
- mybatis
- aspect
- springwebmvc
- spring-jdbc
- mybatis-spring
回顾Mybatis
pojo
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
Mapper接口
public interface UserMapper {
public List<User> selectUser();
}
Mapper实现类
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.XZY_SUNSHINE.Mapper.UserMapper">
<select id="selectUser" resultType="User" >
select * from mybatis.user
</select>
</mapper>
mybatisconfig.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
<typeAliases>
<typeAlias type="com.XZY_SUNSHINE.pojo.User" alias="User"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" 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="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/XZY_SUNSHINE/Mapper/UserMapper.xml"/>
</mappers>
</configuration>
测试
@Test
public void test() throws Exception {
InputStream userMapper = Resources.getResourceAsStream("MybatisConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(userMapper);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
整合Mybatis方式一
UserMapperImpl.java
public class UserMapperImpl implements UserMapper{
private SqlSessionTemplate Sqlsession;
public UserMapperImpl(SqlSessionTemplate sqlsession) {
this.Sqlsession = sqlsession;
}
@Override
public List<User> selectUser() {
return Sqlsession.getMapper(UserMapper.class).selectUser();
}
}
Spring-Mybatis.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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.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="123456"/>
</bean>
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="DataSource"/>
<property name="configLocation" value="classpath:MybatisConfig.xml"/>
<property name="mapperLocations" value="classpath:com/XZY_SUNSHINE/Mapper/UserMapper.xml"/>
</bean>
<bean id="SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
<bean id="UserMapper" class="com.XZY_SUNSHINE.Mapper.UserMapperImpl">
<constructor-arg index="0" ref="SqlSession"/>
</bean>
</beans>
Myabtis.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
<typeAliases>
<typeAlias type="com.XZY_SUNSHINE.pojo.User" alias="User"/>
</typeAliases>
</configuration>
Test
@Test
public void test() throws Exception {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-Mybatis.xml");
UserMapper mapper = (UserMapper) context.getBean("UserMapper");
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
Mybatis整合方式二
UserMapperImpl2.java
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}
Spring-Mybatis.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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.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="123456"/>
</bean>
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="DataSource"/>
<property name="configLocation" value="classpath:MybatisConfig.xml"/>
<property name="mapperLocations" value="classpath:com/XZY_SUNSHINE/Mapper/UserMapper.xml"/>
</bean>
<bean id="SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
<bean id="UserMapper2" class="com.XZY_SUNSHINE.Mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="SqlSessionFactory"/>
</bean>
</beans>
Test
@Test
public void test() throws Exception {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-Mybatis.xml");
UserMapper mapper = (UserMapper) context.getBean("UserMapper2");
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
声明式事务
回顾事务
- 要么都成功,要么都失败
- 事务在项目开发中,十分的重要,涉及到数据的一致性问题。
- 确保完整性和一致性
ACID
- 原子性
- 一致性
- 隔离性
- 持久性
spring中的事务管理
- 声明式事务:AOP
- 编程式事务:需要在代码中进行事务的管理
声明式事务
配置事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg ref="DataSource" />
</bean>
配置事务的类
<tx:advice id="txAdvice">
<tx:attributes>
<tx:method name="selectUser"/>
<tx:method name="updateUser"/>
<tx:method name="deleteUser"/>
</tx:attributes>
</tx:advice>
AOP配置
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.XZY_SUNSHINE.Mapper.UserMapperImpl2.*(..))"/>
</aop:config>
<bean id="UserMapper2" class="com.XZY_SUNSHINE.Mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="SqlSessionFactory"/>
</bean>
```
Test
@Test
public void test() throws Exception {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-Mybatis.xml");
UserMapper mapper = (UserMapper) context.getBean("UserMapper2");
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}