Spring总结

简介

官网：

https://spring.io/projects/spring-framework#overview

官方文档地址：

https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/core.html#beans-introduction

官方下载地址：

http://repo.spring.io/release/org/springframework/spring

GitHub：

https://github.com/spring-projects/spring-framework

环境配置

maven依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

Spring 配置文件头部

<?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">
    
    
</beans>

业务代码编写步骤

创建实体类

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }
	//必须要写set方法
    public void setStr(String str) {
        this.str = str;
    }
    
    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

创建配置文件（在 resources 资源目录下创建 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">

    <bean id="hello" class="com.qiu.pojo.Hello">
        <property name="str" value="学习Spring"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用，直接去里面取出来就可以！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

基础知识点

使用有参构造创建对象

使用下标赋值

<bean id="user" class="com.qiu.pojo.User">
    <!-- 参数下标从0开始，依次类推 -->
    <constructor-arg index="0" value="湫"/>
</bean>

使用变量名称

<bean id="user" class="com.qiu.pojo.User">
    <!-- 使用 实体类属性名 赋值 -->
    <constructor-arg name="name" value="湫"/>
</bean>

使用类型赋值，一般不用，可以自己百度了解

Bean配置

<!--
  id: bean 的唯一标识符，也就是相当于我们学的对象名
  class: bean对象所对应的全限定名 （包名+类名）
  name: 也是别名，而且name 可以同时取多个别名
-->
<!--
  value: 具体的值，基本数据类型
  ref: 引用Spring容器中创建好的对象
-->
<bean id="user" class="com.qiu.pojo.User" name="user2,u1,u2">
    <property name="name" value="湫"/>
</bean>

import标签

一般用于团队开发使用，他可以将多个配置文件，导入合并为一个

现在有三个配置文件（applicationContext.xml、beans.xml、beans1.xml）

在 applicationContext.xml 的配置文件中引入其它两个配置文件

<import resource="beans.xml"/>
<import resource="beans1.xml"/>

使用的时候，直接使用总的配置就可以了

别名

<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>

依赖注入

除了 构造器注入 方式外，还有 Set方式注入

各种复杂类型

基本类型、String类、对象、数组、List、Map、Set、null、Properties

真实测试对象

private String name;	// String
private Address address;	// 对象引用
private String[] books;	// 数组
private List<String> hobbes;	// List集合
private Map<String,String> card;	// Mao集合
private Set<String> games;	// Set
private String wife;	// null
private Properties info;	// 配置相关

注入方式

<bean id="address" class="com.qiu.pojo.Address">
    <property name="address" value="杭州"/>
</bean>

<bean id="student" class="com.qiu.pojo.Student" name="stu">
    <!--普通值 注入，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="hobbes">
        <list>
            <value>听歌</value>
            <value>敲代码</value>
            <value>看电影</value>
        </list>
    </property>
    <!--Map 注入，map标签-->
    <property name="card">
        <map>
            <entry key="身份证" value="131121204514512"/>
            <entry key="银行卡" value="102001621220512"/>
        </map>
    </property>
    <!--Set 注入，set标签-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>BOB</value>
            <value>COC</value>
        </set>
    </property>
    <!--null-->
    <property name="wife">
        <null/>
    </property>
    <!--Properties 配置注入，props标签-->
    <property name="info">
        <props>
            <prop key="driver">com.mysql.jdbc.Driver</prop>
            <prop key="url">jdbc:mysql://localhost:3306/mybatis</prop>
            <prop key="username">root</prop>
            <prop key="password">123456</prop>
        </props>
    </property>
</bean>

输出结果

Student{
 name='湫',
 address='杭州',
 books=[红楼梦, 西游记, 水浒传, 三国演义],
 hobbes=[听歌, 敲代码, 看电影],
 card={身份证=131121204514512, 银行卡=102001621220512},
 games=[LOL, BOB, COC],
 wife='null',
 info={password=123456, url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8, driver=com.mysql.jdbc.Driver, username=root}
}

拓展方式

我们可以使用 p命名空间和 c命名空间进行注入

通过 p标签 注入

<!--引入 第三方约束（xmlns:p）-->
xmlns:p="http://www.springframework.org/schema/p"

<!--p命名空间注入，可以直接注入属性的值：property-->
<bean id="user" class="com.qiu.pojo.User"
	p:name="湫" p:age="18"
/>

通过 c标签 注入

<!--引入 第三方约束（xmlns:c）-->
xmlns:c="http://www.springframework.org/schema/c"

<!--c命名空间注入，通过构造器注入：construct-args-->
<bean id="user2" class="com.qiu.pojo.User"
	c:name="湫" c:age="20"
/>

注意点：p命名和 c命名不能直接使用，需要导入xml约束！

bean的作用域

Scope	Description
singleton	(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
prototype	Scopes a single bean definition to any number of object instances.
request	Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring `ApplicationContext`.
session	Scopes a single bean definition to the lifecycle of an HTTP `Session`. Only valid in the context of a web-aware Spring `ApplicationContext`.
application	Scopes a single bean definition to the lifecycle of a `ServletContext`. Only valid in the context of a web-aware Spring `ApplicationContext`.
websocket	Scopes a single bean definition to the lifecycle of a `WebSocket`. Only valid in the context of a web-aware Spring `ApplicationContext`.

代理模式（Spring默认机制）

<bean id="hello" class="com.qiu.pojo.Hello" scope="singleton">

singleton

创建的对象相等（user1==user2 为 true）

原型模式

每次从容器中get的时候，都会产生一个新对象！

<bean id="hello" class="com.qiu.pojo.Hello" scope="prototype">

prototype

创建的对象不相等（user1==user2 为 false）

Bean的自动装配

环境搭建

一个人有两个宠物！

<bean id="cat" class="com.qiu.pojo.Cat"/>
<bean id="dog" class="com.qiu.pojo.Dog"/>

<bean id="people" class="com.qiu.pojo.People">
    <property name="name" value="湫"/>
    <property name="cat" ref="cat"/>
    <property name="dog" ref="dog"/>
</bean>

ByName自动装配

<bean id="cat" class="com.qiu.pojo.Cat"/>
<bean id="dog" class="com.qiu.pojo.Dog"/>
<!-- 
   byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的 beanid
	并且区分大小写
-->
<bean id="people" class="com.qiu.pojo.People" autowire="byName">
    <property name="name" value="湫"/>
</bean>

ByType自动装配

<bean class="com.qiu.pojo.Cat"/>
<bean class="com.qiu.pojo.Dog"/>

<!--
   byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean
	引用对象注册时，id可以去掉不写
	必须保证 类型全局唯一
-->
<bean id="people" class="com.qiu.pojo.People" autowire="byType">
    <property name="name" value="湫"/>
</bean>

小结：

byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

使用注解实现自动装配

要使用注解须知：

导入约束
配置注解的支持（官方文档 1.9）

<?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（Spring）容器中存在，且名字符合

byType和byName；

科普：

@Nullable //字段标记了这个注解，说明这个字段可以为null；

public People(@Nullable String name){
    this.name = name;
}

@Autowired 的使用

public class People {
    private String name;
    //如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
}

<bean id="cat" class="com.qiu.pojo.Cat"/>
<bean id="dog" class="com.qiu.pojo.Dog"/>
<!--beans.xml文件中不需要装配-->
<bean id="people" class="com.qiu.pojo.People">
    <property name="name" value="湫"/>
</bean>

如果 @Autowired 自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以

使用 @Qualifier (value = "xxx")去配置 @Autowired 的使用，指定一个唯一的bean对象注入！

<bean id="cat1" class="com.qiu.pojo.Cat"/>
<bean id="dog2" class="com.qiu.pojo.Dog"/>

<bean id="people" class="com.qiu.pojo.People">
    <property name="name" value="湫"/>
</bean>

@Autowired
@Qualifier(value = "cat1")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

还可以使用Java的原生注解【@Resource】

jdk11中被移除~

@Resource
private Cat cat;
@Resource
private Dog dog;

//也可以使用 name 来指定 beanid
@Resource（name="cat1"）

小结

@Resource 和 @Autowired 的区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired 通过byType的方式实现的，而且必须要求这个对象存在！【常用】
@Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
执行顺序不同：
- @Autowired 自动装配通过类型，然后是名字
- @Resource 自动装配通过名字，然后是类型

使用注解开发

在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:annotation-config/>

</beans>

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.qiu.pojo"/>

Bean 注册

<!--使用 配置方式 -->
<bean id="user" class="com.qiu.pojo.User"/>

//使用注解方法

// @Component组件
@Component
public class User {
    public String name ="湫";
}

public static void main(String[] args) {
    ApplicationContext context = new
        ClassPathXmlApplicationContext("applicationContext.xml");
    User user = context.getBean("user", User.class);	//id默认为类名的小写
    System.out.println(user.name);
}

属性如何注入

<!--使用 配置方式 -->
<property name="name" value="qiu"/>

//使用注解

@Component
public class User {
    @Value("qiu")
    public String name;
}
// 也可以放在 set方法上

自动装配置

@Autowired ：自动装配通过类型，名字
@Qualifier(value = "xxx") ：@Autowired 不能唯一自动装配时，可指定一个唯一的bean对象注入
@Resource ：自动装配通过名字，类型

作用域

@Scope("singleton") //单例模式
@Scope("prototype") //原型模式

注意点

我们在使用的过程中，需要注意一个问题：必须让注解生效，就需要开启注解的支持

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.qiu.pojo"/>
<context:annotation-config/>

使用Spring实现AOP

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

类型通知	连接点	实现接口
前置通知	方法前	org.springframework.aop.BeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.aopalliance.intercept.MethodInterceptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.InteoductionInterceptor

即AOP在不改变原有代码的情况下，去增加新的功能！

导入依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

xml中要添加AOP的约束

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

方式一使用Spring的API接口【主要SpringAPI接口实现】

定义接口和实现类

public interface UserService {
    void add();
    void del();
    void update();
    void select();
}

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("添加了一个用户");
    }
    public void del() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void select() {
        System.out.println("查询了一个用户");
    }
}

实现 MethodBeforeAdvice 接口

//前置增强
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] args, Object target) {
        System.out.println(target.getClass().getName()+"的"+
                method.getName()+"被执行了");
    }
}

实现 AfterReturningAdvice 接口

//后置增强
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
    //returnValue:返回值
    public void afterReturning(Object returnValue, Method method, Object[] args,
                               Object target) {
            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
        http://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.qiu.service.UserServiceImpl"/>
    <bean id="log" class="com.qiu.log.Log"/>
    <bean id="afterLog" class="com.qiu.log.AfterLog"/>

    <!--方式一：使用原生Spring API 接口-->
    <!--配置AOP；需要导入aop的约束-->
    <aop:config>
        <!--切入点的命名，要切入的方法-->
			<!--
            1、execution(): 表达式主体。
            2、第一个*号：表示返回类型， *号表示所有的类型。
            3、包名：表示需要拦截的包名com.qiu.service包、子孙包下所有类的方法。
            4、第二个*号：表示类名，*号表示所有的类，可以写具体类（UserServiceImpl）
            5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数
			-->
        <aop:pointcut id="pointcut" expression="execution(* com.qiu.service.*.*(..))"/>
        <!--配置切入类，到具体的切入点-->
        <!--执行环绕增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理 代理的是接口
        UserService userService = (UserService) context.getBean("userService");
        userService.update();
    }
}

方式二使用注解实现

编写自定义类，并配上注解

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.qiu.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("========方法执行前========");
    }
    @After("execution(* com.qiu.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("========方法执行后========");
    }

    @Around("execution(* com.qiu.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //获得签名
        System.out.println(jp.getSignature());
        //执行方法
        jp.proceed();
        System.out.println("环绕后");
    }
}

XML配置文件

<!--方式三：使用注解-->
<bean id="annotationPointCut" class="com.qiu.diy.AnnotationPointCut"/>
<!--开启注解支持！-->
<!--JDK（默认）  proxy-target-class="false"-->
<!--cglib       proxy-target-class="true"-->
<aop:aspectj-autoproxy/>
<!--<aop:aspectj-autoproxy proxy-target-class="true"/>-->

输出结果：

环绕前
void com.qiu.service.UserService.update()
========方法执行前========
更新了一个用户
环绕后
========方法执行后========

整合Mybatis【重点】

导入相关jar包

junit、mybatis、mysql数据库、spring相关的、aop织入、mybatis-spring

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <!--Spring操作数据库的话，还需要一个spring-jdbc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</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.16.10</version>
    </dependency>
</dependencies>

回忆mybatis

编写实体类
编写核心配置文件【mybatis-config.xml】
UserMapper 接口
编写Mapper.xml
测试

public void test() throws IOException {
    String resources = "mybatis-config.xml";
    InputStream in = Resources.getResourceAsStream(resources);
    SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
    SqlSession sqlSession = sessionFactory.openSession(true);

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = mapper.selectUser();
    for (User user : userList) {
        System.out.println(user);
    }
}

Mybatis-spring

官网：

http://mybatis.org/spring/zh/index.html

整合Mybatis方式一：

1. 创建 spring-dao.xml 文件
	配置 DataSource
	配置 sqlSessionFactory
2. 绑定 SqlSessionTemplate
3. 编写接口实现类
4. Spring中注册 接口实现类
5. 测试

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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--DataSource:使用Spring的数据源替换Mybatis的配置  c3p0 dbcp druid
        这里使用Spring提供的JDBC：org.springframework.jdbc.datasource
    -->
    <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&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <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"/>
    </bean>

    <!--SqlSessionTemplate 就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--因为没用set方法，只能使用构造器注入sqlSessionFactory-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

接口及实现类

import com.qiu.pojo.User;
import java.util.List;
public interface UserMapper {
    List<User> selectUser();
}

import com.qiu.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper {
    //在原来，我们所有的操作都使用sqlSession来执行，现在我们都是用SqlSessionTemplate实现
    private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

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核心配置文件-->
<configuration>
    <!--实体类别名-->
    <typeAliases>
        <package name="com.qiu.pojo"/>
    </typeAliases>

    <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/qiu/mapper/UserMapper.xml" />
    </mappers>
</configuration>

applicationContext文件

<?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">
    
    <import resource="spring-dao.xml"/>
    <bean id="userMapper" class="com.qiu.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

测试

public class MyTest {
    @Test
    public void test() {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

整合Mybatis方式二：

使用 SqlSessionDaoSupport 方式实现
	不再需要 SqlSessionTemplate
	配置时直接使用 sqlSessionFactory

接口实现类：

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

XML配置

<bean id="userMapper2" class="com.qiu.mapper.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

Spring中的事务管理

声明式事务：AOP
编程式事务：需要在代码中，进行事务的管理

声明式事务：

<!--需要在开头引入 第三方约束-->
xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd

在 spring-dao.xml 文件后面添加下面代码即可

<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--结合AOP实现事务的织入-->
<!--配置事务通知：-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给那些方法配置事务-->
    <!--配置事务的传播特性：new propagation= -->
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" 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.qiu.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

Spring中常用注解说明

@Autowired ：自动装配通过类型，名字

@Qualifier(value = "xxx") ：@Autowired不能唯一自动装配时，可指定一个唯一的bean对象注入

@Resource ：自动装配通过名字，类型

@Nullable ：字段标记了这个注解，说明这个字段可以为null；

@Component ：组件，放在类上，说明这个类被Spring管理了，就是bean！

@Value("xxx") ：属性赋值，可以放在属性上，也可放在set方法上

posted @ 2020-06-22 18:35 Qiu-F 阅读(164) 评论(0) 收藏举报

刷新页面返回顶部

湫