Spring 笔记

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量306 收藏
点赞数
分类专栏： Java Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q12584154/article/details/122287796
版权

Spring-Study

Kuang shen Spring study in bilibili

1. 简介

spring理念：是现有的技术更加容易使用，本身是一个大杂烩。

  • SSH：Struct2 + Spring + Hibernate

  • SSM: SpringMVC + Spring + Mybatis

官网： Spring Framework

官方下载： JFrog

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

Spring Web MVC » 5.2.5.RELEASE

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

1.1、组成

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

  • 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

  • Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

  • Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

  • Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

  • Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

  • Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

  • Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.2、拓展

Spring Boot与Spring Cloud

  • Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;

  • Spring Cloud是基于Spring Boot实现的；

  • Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；

  • Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。

  • SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

图片

2.IOC理论

新建一个空白的maven项目

2.1、分析实现（非常重要！！IOC底层原理）

我们先用我们原来的方式写一段代码 .

1、先写一个UserDao接口

public interface UserDao {
   public void getUser();
}

2、再去写Dao的实现类

public class UserDaoImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("获取用户数据");
  }
}

3、然后去写UserService的接口

public interface UserService {
   public void getUser();
}

4、最后写Service的实现类

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoImpl();
​
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

5、测试一下

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .

把Userdao的实现类增加一个 .

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();
​
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaoOracleImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("Oracle获取用户数据");
  }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

大家发现了区别没有 ? 可能很多人说没啥区别 . 但是同学们 , 他们已经发生了根本性的变化 , 很多地方都不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

2.2、IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

图片

在使用Spring框架后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器。

从Spring容器的角度，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

图片

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3. Hello Spring

3.1、导入Jar包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

3.2 、编写代码

1、编写一个Hello实体类

public class Hello {
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

2、编写我们的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
       http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	
    <!--bean = 对象-->
    <!--id = 变量名-->
    <!--class = new的对象-->
    <!--property 相当于给对象中的属性设值-->
    
	
   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.king.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>

</beans>

3、我们可以去进行测试了 .

@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

3.2、思考

  • Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的

  • Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

3.3、修改案例一

我们在案例一中， 新增一个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
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="MysqlImpl" class="com.king.dao.impl.UserDaoMySqlImpl"/>
   <bean id="OracleImpl" class="com.king.dao.impl.UserDaoOracleImpl"/>

   <bean id="ServiceImpl" class="com.king.service.impl.UserServiceImpl">
       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
       <!--引用另外一个bean , 不是用value 而是用 ref-->
       <property name="userDao" ref="OracleImpl"/>
   </bean>

</beans>

测试！

@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
   serviceImpl.getUser();
}

OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

4. IOC创建对象的方式

4.1、通过无参构造方法来创建

1、User.java

public class User {

   private String name;

   public User() {
       System.out.println("user无参构造方法");
  }

   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("name="+ name );
  }

}

2、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="user" class="com.king.pojo.User">
       <property name="name" value="kingdom"/>
   </bean>

</beans>

3、测试类

@Test
public void test(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //在执行getBean的时候, user已经创建好了 , 通过无参构造
   User user = (User) context.getBean("user");
   //调用对象的方法 .
   user.show();
}

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

4.2、通过有参构造方法来创建

1、UserT . java

public class UserT {

   private String name;

   public UserT(String name) {
       this.name = name;
  }

   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("name="+ name );
  }

}

2、beans.xml 有三种方式编写

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.king.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="kingdoms"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.king.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kindoms"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.king.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kingdoms"/>
</bean>

3、测试

@Test
public void testT(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserT user = (UserT) context.getBean("userT");
   user.show();
}

结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

5. Spring配置

5.1、别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

5.2、Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hellogo h2,h3;h4" class="com.king.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

5.3、import

团队的合作通过import来实现 .

<import resource="{path}/beans.xml"/>

6. DI依赖注入

6.1、概念

  • 依赖注入（Dependency Injection,DI）。

  • 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .

  • 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

依赖注入的作用就是在使用Spring框架创建对象的时候，动态地将其所依赖的对象注入 Bean 组件中，其实现方式通常有两种，一种是属性setter方式注入，另一种是构造方法注入。

6.2、构造器注入

我们在之前的案例已经讲过了

6.3、Set 注入 （重点）

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试pojo类 :

Address.java

public class Address {
 
     private String address;
 
     public String getAddress() {
         return address;
    }
 
     public void setAddress(String address) {
         this.address = address;
    }
 }

Student.java

package com.king.pojo;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 
 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 String wife;
     private Properties info;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAddress(Address address) {
         this.address = address;
    }
 
     public void setBooks(String[] books) {
         this.books = books;
    }
 
     public void setHobbys(List<String> hobbys) {
         this.hobbys = hobbys;
    }
 
     public void setCard(Map<String, String> card) {
         this.card = card;
    }
 
     public void setGames(Set<String> games) {
         this.games = games;
    }
 
     public void setWife(String wife) {
         this.wife = wife;
    }
 
     public void setInfo(Properties info) {
         this.info = info;
    }
 
     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);
 
         System.out.println("card:"+card);
 
         System.out.println("games:"+games);
 
         System.out.println("wife:"+wife);
 
         System.out.println("info:"+info);
 
    }
 }

1、常量注入

<bean id="student" class="com.king.pojo.Student">
     <property name="name" value="小天"/>
 </bean>

测试：

 @Test
 public void test01(){
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 
     Student student = (Student) context.getBean("student");
 
     System.out.println(student.getName());
 
 }

2、Bean注入

注意点：这里的值是一个引用，ref

<bean id="adds" class="com.king.pojo.Address">
     <property name="address" value="四川"/>
 </bean>
 
 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小天"/>
     <property name="address" ref="adds"/>
 </bean>

3、数组注入

<bean id="student" class="com.king.pojo.Student">
     <property name="name" value="小天"/>
     <property name="address" ref="adds"/>
     <property name="books">
         <array>
             <value>西游记</value>
             <value>三国演义</value>
             <value>红楼梦</value>
             <value>水浒传</value>
         </array>
     </property>
 </bean>

4、List注入

 <property name="hobbys">
     <list>
         <value>听歌</value>
         <value>看电影</value>
         <value>爬山</value>
     </list>
 </property>

5、Map注入

<property name="card">
     <map>
         <entry key="中国邮政" value="456456456465456"/>
         <entry key="建设" value="1456682255511"/>
     </map>
 </property>

6、set注入

<property name="games">
     <set>
         <value>LOL</value>
         <value>BOB</value>
         <value>COC</value>
     </set>
 </property>

7、Null注入

 <property name="wife"><null/></property>

8、Properties注入

<property name="info">
     <props>
         <prop key="学号">20190604</prop>
         <prop key="性别">男</prop>
         <prop key="姓名">小明</prop>
     </props>
 </property>

p命名和c命名注入

User.java ：【注意：这里没有有参构造器！】

 public class User {
     private String name;
     private int age;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAge(int age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }

1、P命名空间注入 : 需要在头文件中加入约束文件

<!--导入约束 : xmlns:p="http://www.springframework.org/schema/p"-->
 
 <!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.king.pojo.User" p:name="求水山" p:age="18"/>

2、c 命名空间注入 : 需要在头文件中加入约束文件

 <!--导入约束 : xmlns:c="http://www.springframework.org/schema/c"-->
 <!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.king.pojo.User" c:name="秋山" c:age="18"/>

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

测试代码：

 @Test
 public void test02(){
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
     User user = (User) context.getBean("user");
     System.out.println(user);
 }

7. Bean的自动装配

  • 自动装配是Spring是满足bean依赖的一种方式

  • Spring会在上下文自动寻找，并自动给bean装配属性

==在Spring中有三种装配的方式==

  1. 在xml中显示配置

  2. 在java中显示配置

  3. 隐式的自动装配bean

  1. 环境搭建：一个人有两个宠物

  2. Byname自动装配：byname会自动查找，和自己对象set对应的值对应的id

    保证所有id唯一，并且和set注入的值一致

  3. Bytype自动装配：byType会自动查找，和自己对象属性相同的bean

    保证所有的class唯一

public class Cat {
    public void jiao(){
        System.out.println("miao");
    }
}
public class Dog {

    public void jiao(){
        System.out.println("wow");
    }

}
package com.pojo;


public class People {

    private Cat cat;
    private Dog dog;
    private String name;

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.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">

    <bean id="cat11" class="com.pojo.Cat"/>
    <bean id="dog" class="com.pojo.Dog"/>
    <!--byname会自动查找，和自己对象set对应的值对应的id-->
    <!--<bean id="people" class="com.pojo.People" autowire="byName">-->
        <!--<property name="name" value="hou"></property>-->
    <!--</bean>-->
    <!--byType会自动查找，和自己对象属性相同的bean-->
    <bean id="people" class="com.pojo.People" autowire="byType">
        <property name="name" value="hou"></property>
    </bean>

</beans>

使用注解自动装配

jdk1.5支持的注解，spring2.5支持的注解

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

导入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>

@Autowire

在属性上个使用，也可以在set上使用

我们可以不用编写set方法了

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}
@Nullable 字段标志的注解，说明这个字段可以为null

如果@Autowired自动装配环境比较复杂。自动装配无法通过一个注解完成的时候

我们可以使用@Qualifier(value = "dog")去配合使用，指定一个唯一的id对象

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;
}

@Resource(name="dog")也可以

区别：

  • @autowire通过byType实现，而且必须要求这个对象存在

  • @resource默认通过byName实现，如果找不到，通过byType实现

8. 使用注解开发

在spring4之后，必须要保证aop的包导入

使用注解需要导入contex的约束

<?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>

1.属性如何注入

@Component
public class User {
    
    @Value("dong")
    private String name;

    public String getName() {
        return name;
    }


}

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

@Component
public class User{
	public String name
}
 等价于

<bean id = "user" class = "com.king.pojo.User" />

@Value：

public class User{
	@Value("King")
	public String name;
    
        /// 也可以注入到set方法上
        @Value("King")
        public void setName(String name) {
        	this.name = name;
        }
}
 等价于

<property name ="name" value = "King">

2.衍生的注解

@Component有几个衍生注解，会按照web开发中，mvc三层架构分层。

  • dao （@Repository）x

  • service（@Service）

  • controller（@Controller）

这四个注解功能一样的，都是代表将某个类注册到容器中

3.自动装配

@Autowired : 自动装配类型。名字 如果Autowired 不能唯一自动装配，则需要 @Qualifier(value="xxx") - @Nullable "xxx"表示的是bean-id ，字段标记了这个注解，说明这个字段可以用NULL @Resource : 自动装配通过名字。类型 （和上面一样是有顺序性）

3.作用域

@Scope("singleton")

@Component
@Scope("prototype")
public class User {

    @Value("dong")
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

小结：

xml与注解

  • xml更加万能，维护简单

  • 注解，不是自己的类，使用不了，维护复杂

最佳实践：

  • 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: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/>
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.king"/>

</beans>

9. 使用java方式配置spring（纯java，不用Spring）

我们现在要完全不使用Spring的xml配置了，全权交给java来做

JavaConfig是Spring的一个子项目，在spring4之后，他成为了核心功能

配置文件

 // 这个也会被spring容器托管，注册到容器中，因为他本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.pojo")	// 扫描包
@Import(Config2.class)
public class MyConfig {

    // 注册一个bean，就相当于我们之前写的一个bean标签
    // 他们函数名，就相当于 bean.id
    // 他的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }

}

image-20210816110058115

实体类

@Component
public class User {

    @Value("dong")
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试类

public class MyTest { 
    public static void main(String[ ] args) { 
    //如果完全使用了配置类方式去做,我们就只能通过 Annotationconfig 上下文来获取容器,通过配置类的class对象加载! 
    ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.Class); //class对象
    User getUser =(User)context.getBean( "getUser"); //方法名getUser
    System.out.Println(getUser.getName()); 
    } 
}

这种纯java配置方式

在springboot中，随处可见

10. 代理模式（动态代理）

为什么要学习代理模式？

因为这是SpringAOP的底层

代理模式的分类：

  • 静态代理

  • 动态代理

image-20210816111900289

10.1、静态代理

image-20210816140437816

代理模式的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务！

  • 公共也就交给代理角色！实现了业务的分工！

  • 公共业务发生拓展的时候，方便拓展管理。

缺点：

  • 一个真实角色就又会产生一个代理角色，代码量会翻倍，开发效率变低（解决这个的办法，就是动态代理）

代码步骤

  1. 接口（抽象角色）

    public interface Rent {
	public void rent();
}

  2. 真实角色

public class Host implements Rent {
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

  1. 代理角色

public class Proxy {

	public Host host;
	
	public Proxy() {
	}
	
	public Proxy(Host host) {
		super();
		this.host = host;
	}
	
	public void rent() {
		seeHouse();
		host.rent();
		fee();
		sign();
	}
        // 自己找房东看房子就只有1套，但是中介可以带你看很多很多套
	//看房
	public void seeHouse() {
		System.out.println("看房子");
	}
	//收费
	public void fee() {
		System.out.println("收中介费");
	}
	//合同
	public void sign() {
		System.out.println("签合同");
	}		
}

  1. 客户端访问代理角色

        
        
        ProxyInvocation proxyInvocation = new ProxyInvocation();


import pojo.Host;
import pojo.HostMaster;
import pojo.Proxy;

public class My {

	public static void main(String[] args) {
		//房东要出租房子
		Host host = new HostMaster();
		//中介帮房东出租房子，但也收取一定费用（增加一些房东不做的操作）
        	/// 代理角色一般有很多附属操作
      	      // 代理角色， 中介帮房东租房子
		Proxy proxy = new Proxy(host);
		//看不到房东，但通过代理，还是租到了房子
		proxy.rent();
		
	}
}

10.2、加深理解

如果我们要新增一个log日志功能，通常情况下，我们是直接在真实角色的源代码中直接cout，但是我们采用的是在代理角色中，新增一个方法，进行横向的修改。

这样就不会影响原有的代码逻辑！

在公司中，你就不需要改别人的代码实现系统功能的更新

image-20210816143919203

  1. 接口（抽象角色）

    // 抽象角色
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

  2. 真实角色

// 真实对象
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 query() {
        System.out.println("查询了一个用户");
    }
}

  1. 代理角色

// 代理角色
public class UserServiceProxy implements UserService{
    UserServiceImpl userService = new UserServiceImpl();

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");	// 加了这个功能的代码
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    // 加一个日志方法
    public void log(String msg){
        System.out.println("[Debug]使用了"+msg+"方法");
    }

    // 1.改动原有代码在公司中是大忌，所以就多一层多一个方法

}

  1. 客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        // userService.add();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
    }
}

10.3、动态代理

解决静态代理的缺点，既想让分工明确，又不想让代码量增加（上个demo中每个函数还是加了log函数）

  • 动态代理和静态代理，角色一样。

  • 动态代理的类，是动态生成的，不是我们直接写好的。

  • 动态代理分为两大类：①基于接口的动态代理，②基于类的动态代理

    ①基于接口：JDK 动态代理【我们在这里使用】

    ②基于类：cglib

    ③java字节码实现：javasist（但是不用用于Tomcat，而是JBoss服务器）

需要两个类：①Proxy：代理，②InvocationHandler：调用处理程序

InvocationHandler：调用处理程序

Proxy：代理

Object invoke(Object proxy, Method method, Object[] args)；

参数: proxy： 调用该方法的代理实例

method：所述方法对应于调用代理实例上的接口方法的实例（要运行的方法）。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。

args：包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);

image-20210816161224509

代码实现

抽象角色

public interface Rent {
    public void rent();

}

真实角色

public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子!");
    }
}

代理角色

// 等会我们会用这个类，动态生成代理类!
public class ProxyInvocationHandler implements InvocationHandler {

    // 被代理的接口(被代理的方法,比如说是增删改查的某一种)
    private  Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    // 1.生成得到代理类,固定的代码,只需要改Rent
    public Object getProxy(){
        //                                          加载到类在那个位置,要代理的接口是哪一个接口         调用他自己来处理
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
    }

    // 2.处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 用invoke 来执行反射方法
        // 动态代理的本质，就是使用反射机制来实现！
        Object result =  method.invoke(rent,args);  // 为什么会执行rent方法，就是因为在这里调用自己

        // 新加的方法直接在后面加上就好了,直接放到反射的类里面处理就好了
        seeHouse();
        fare();
        return result;
    }

    // 新加一个方法
    public void seeHouse(){
        System.out.println("中介带看房子");
    }

    public void fare(){
        System.out.println("收中介费");
    }

}

访问客户

public class Client {

    public static void main(String[] args) {
        // 真实角色
        Host host = new Host();

        // 代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();  // 创建代理
        // 通过调用程序处理角色来处理我们要调用的接口
        pih.setRent(host);

        Rent proxy = (Rent) pih.getProxy(); // 这里的proxy是动态生成的，我们并没有写

        proxy.rent();   // 这里进入 invoke

    }
}

之后我们可以把代理角色公式化

// 写成活的，
public class ProxyInvocationHandler implements InvocationHandler {

    // private Rent rent;
    // 我们之前代理的是一个死的接口，现在我们可以把它变活
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    // 1.生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    // 2.处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 用invoke 来执行反射方法
        // 动态代理的本质，就是使用反射机制来实现！
        Object result =  method.invoke(target,args);  // 为什么会执行rent方法，就是因为在这里调用自己
        log(method.getName());  // 通过反射来得到函数名字
        /// 新加的方法直接在后面加上就好了,直接放到反射的类里面处理就好了

        return result;
    }

    // 新加一个方法，加一个日志的功能

    public  void log(String msg) {
        System.out.println("[Debug]执行了"+msg+"方法");
    }

}

客户

public class Client {
    public static void main(String[] args) {
        /// 真实角色
        UserServiceImpl userService = new UserServiceImpl();
        /// 代理角色,不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        /// 设置要代理的对象
        pih.setTarget(userService);
        /// 动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

静态代理有的它都有，静态代理没有的，它也有！

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

  • 公共的业务由代理来完成 . 实现了业务的分工 ,

  • 公共业务发生扩展时变得更加集中和方便 .

  • 一个动态代理 , 一般代理某一类业务

  • 一个动态代理可以代理多个类，代理的是接口！

11.AOP

11.1、什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

img

11.2、Aop在Spring中的作用

==提供声明式事务；允许用户自定义切面==

以下名词需要了解下：

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ....

  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。

  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

  • 目标（Target）：被通知对象。

  • 代理（Proxy）：向目标对象应用通知之后创建的对象。

  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。

  • 连接点（JointPoint）：与切入点匹配的执行点。

image-20210816165530024

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

image-20210816165930039

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能。

11.3、使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

方法一：

使用Spring API接口 【主要是Spring API接口实现】

首先编写我们的业务接口和实现类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}
/// 真实对象
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("查询了一个用户");
    }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

// 前置日志
public class Log implements MethodBeforeAdvice {

    // method : 要执行的目标对象方法
    // object : 参数
    // target : 目标读写
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了" );
    }
}
// 后置日志
public class AfterLog implements AfterReturningAdvice {

    // returnValue : 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println( "执行了" + method.getName() + "方法,返回结果为：" + returnValue );
    }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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-->
    <bean id="userService" class="com.king.service.UserServiceImpl" />
    <bean id="log" class="com.king.log.Log" />
    <bean id="afterLog" class="com.king.log.AfterLog" />

    <!--方式一：使用Spring Aop 原生态接口-->
    <!-- 配置Aop:需要导入aop的约束 -->
    <aop:config>
        <!-- 切入点:expression:表达式，execution(要执行的位置!) *是里面任意的方法  -->
        <aop:pointcut id="pointcut" expression="execution(* com.king.service.UserServiceImpl.*(..) )"/>

        <!-- 执行环绕增加! 把Log这个类切入到 excution里面  -->
        <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.add();
        userService.select();
    }

}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

方法二：

自定义来实现AOP 【主要是切面定义】

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

class DiyPointcut {

    public void before() {
        System.out.println("---------方法执行前---------");
    }

    public void after() {
        System.out.println("---------方法执行后---------");
    }

}

第二步：去spring中配置

 <!-- 方式二: 自定义类 -->
    <bean id="diy" class="com.king.diy.DiyPointcut" />

    <aop:config>
        <!-- 自定义切面，ref要引用的类 -->
        <aop:aspect ref="diy" >
            <!-- 切入点 -->
            <aop:pointcut id="pointCut" expression="execution(* com.king.service.UserServiceImpl.*(..))"/>
            <!-- 通知 -->
            <aop:before method="before" pointcut-ref="pointCut" />
            <aop:after method="after" pointcut-ref="pointCut" />
        </aop:aspect>

    </aop:config>

方法三：

注解方式

第一步：编写一个注解实现的增强类

// 如果不写xml，直接在这里 @Component
@Aspect // 标注这个类是一个切面
public class AnnotationPointcut {

    @Before("execution(* com.king.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    }

    @After("execution(* com.hoppz.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }

    /// 在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点

    @Around("execution(* com.hoppz.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);

}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!-- 方式三：使用注解 -->
<bean id = "annotationPointcut" class="com.king.diy.AnnotationPointcut" />
<!-- 开启注解支持 -->
<aop:aspectj-autoproxy/>

12. 整合mybatis

文档： mybatis-spring –

12.1、回忆Mybatis

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>Spring2</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-mybaits</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>


        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!-- aop包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>


    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>


</project>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <typeAliases>
        <package name="com.king.pojo"/>
    </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/ssmbuild?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <package name="com.king.mapper"/>
    </mappers>

</configuration>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace = "com.king.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select * from ssmbuild.userInfo;
    </select>

</mapper>
public interface UserMapper {
    List<User> selectUser();
}

12.2、MyBatis-Spring学习

引入Spring之前需要了解mybatis-spring包中的一些重要类；

mybatis-spring –

什么是 MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

在 MyBatis-Spring 中，可使用SqlSessionFactoryBean来创建 SqlSessionFactory。要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--绑定mybatis配置文件-->
    <property name="configLocation" value="classpath:mybaits-config.xml"/>
    <!-- 绑定mapper -->
    <property name="mapperLocations" value = "classpath:com/king/mapper/*.xml"/>
</bean>

注意：SqlSessionFactory需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

<!-- DateSource ： 使用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/ssmbuild?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
    <property name="username" value = "root"/>
    <property name="password" value ="123456"/>
</bean>

在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。

在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。

SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是 < settings> 或 < typeAliases>元素。

需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（<environments>），数据源（<DataSource>）和 MyBatis 的事务管理器（<transactionManager>）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。

模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

<bean id = "sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!--没有set方法，只能用构造器注入-->
    <constructor-arg index = "0" ref = "sqlSessionFactory" />
</bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession 属性，就像下面这样：

public class UserMapperImpl implements UserMapper{
    /// 我们所有的操作，都是用SQLSession来执行在原来，现在都是SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

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

按下面这样，注入 SqlSessionTemplate：

<!---->
<bean id ="userMapper" class="com.king.mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

整合方式1：

  1. 编写数据源配置，以及mybati-config

  2. sqlSessionFactory

  3. sqlSessionTempla

  4. 需要给接口加实现类

  5. 将实现类注册到Spring容器中

  6. 测试

（代码详见Spring-mybaits）

整合方式2：

  1. 将我们上面写的UserDaoImpl修改一下（新加一个继承）

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

  1. 修改bean的配置

<bean id="userDao" class="com.king.mapper.UserDaoImpl">
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

  1. 测试

@Test
public void Test() throws IOException {

    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    UserMapper userMapper = context.getBean("userMapper",UserMapper.class);
    for(User user : userMapper.selectUser()){
        System.out.println(user);
    }

}

13. 声明式事务

13.1、回顾事务

  • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！

  • 事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。

  • 事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID

  1. 原子性（atomicity）

    事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

  2. 一致性（consistency）

    一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

  3. 隔离性（isolation）

    可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

  4. 持久性（durability）

    事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

image-20210818181954927

Road in the mind
关注
专栏目录
spring笔记
04-12
Spring 笔记 Spring 是 Java 企业版（Java EE）应用程序的框架，提供了结构化的配置文件，实现了控制反转（IoC）和面向切面编程（AOP），支持表现层、业务逻辑层和持久层。Spring 的核心是 IoC 和 AOP，能够与主流...
韩顺平Spring笔记
04-30
《韩顺平Spring笔记》是针对Java开发人员深入学习Spring框架的重要参考资料，它源自知名IT教育专家韩顺平的Spring教程。这篇笔记详尽地记录了Spring的核心概念、使用方法和实战技巧，对于理解Spring的工作原理和提升...
升级到Spring 5.3.x之后，GC次数急剧增加，我TM人傻了
hashcon
08-06 521
最近我们项目升级到了 Spring Boot 2.4.6 + Spring Cloud 2020.0.x，通过我的另一系列即可看出：Spring Cloud 升级之路。但是升级后，我们发现 YoungGC 明显增高，分配对象速率明显增高，但是晋升的对象并没有增多，证明都是新创建的对象并且没过多久就可以被回收。我们来看其中一个进程的监控，这时候的 http 请求速率大概在 100 左右： 这就很奇怪了，请求速率并没有那么大，但是通过监控可以看出每秒钟分配了将近两个 G 的内存。在升级之前，这个分配速率大..
maven的java web项目启动找不到spring-web-3.2.5.RELEASE.jar
xcc_2269861428的博客
03-25 1458
1. 右键单击工程项目 ->点击 properties 2. 选择 Deployment Assembly 3. 点击 Add -> Java Build Path Entries -> Next 4. 选择 Maven Dependencies -> Finish -> Apply -> OK 5.重启server -------------------...
Spring笔记
qq_49306008的博客
01-06 2009
Spring笔记 一、Spring概述 1.1、Spring框架是什么 ​ Spring框架是可以在JavaSE/EE中使用的轻量级开源框架，目的是为了解决企业应用开发的复杂性而创建的，Spring的核心是控制反转（IoC）和面向切面编程（AOP）。 ​ Spring的主要作用就是为代码 “解耦”，降低代码间的耦合度，就是让对象和对象（模块和模块）之间的关系不是使用代码关联，而是通过配置来说明。Spring根据代码的功能特点，使用IoC降低业务对象之间的耦合度。IoC使得主业务在相互调用过程中，不用再自
Spring笔记汇总
studyeglish的博客
05-24 491
学习参考 引言 第一个Spring Spring5.x与日志框架的整合 注入（injection） Set注入详解 构造注入 反转控制 与 依赖注入
黑马程序员SSM_Spring笔记(自用)
qq_62656514的博客
10-12 4398
黑马程序员SSM_Spring笔记(自用)
【狂神说】——Spring笔记（全）
java小豪的博客
06-28 7386
Spring : 春天 —>给软件行业带来了春天2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
Spring学习笔记
徐小陌的博客
05-27 2266
Spring学习笔记 第一部分：Spring 概述 1.1 Spring 简介 轻量级开源框架 核心是IOC和AOP 使⽤最多的 Java EE 企业应⽤开源框架 1.2 Spring 发展历程 EJB->Expert One-to-One J2EE Design and Development论文->Spring 1.3 Spring 的优势 ⽅便解耦，简化开发 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进⾏控制，避免硬编码所造成的 过度程序耦合。⽤户也不
狂神说spring笔记
热门推荐
Frank---7的博客
12-31 6万+
B站 https://www.bilibili.com/video/BV1WE411d7Dv 狂神说Spring01：概述及IOC理论推导 https://mp.weixin.qq.com/s/VM6INdNB_hNfXCMq3UZgTQ 狂神说Spring02：快速上手Spring https://mp.weixin.qq.com/s/Sa39ulmHpNFJ9u48rwCG7A 狂神说Spring03：依赖注入（DI）https://mp.weixin.qq.com/s/Nf-cYENenoZpXqDj
spring笔记整理大全（一）
qq_43154385的博客
12-21 5466
1.spring起源：     早期使用java开发企业应用（企业应用系统，比如：人力资源管理系统、OA办公自动化系统、财务系统 ，所有企业应用的系统总称为ERP）使用EJB（Enterprise java Bean）开发，是sun提供的规范，比如：把javabean分为：Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven...
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 222
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
spring -第十四章 spring事务
m0_74606902的博客
11-11 587
要在spring中实现事务有两种方式编程式事务：编写代码手动的开启、提交、回滚事务。声明式事务：使用注解或xml配置文件进行事务管理。
Spring资源加载模块，原来XML就这，活该被注解踩在脚下 手写Spring第六篇了
mkii_hong的博客
11-11 633
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 1074
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 672
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
为何选择Spring AI Alibaba开发智能客服平台？
JavaEdge全是干货的技术号
11-09 789
本文来看如何使用Spring AI Alibaba构建Agent应用。
狂神spring笔记
09-09
狂神的Spring笔记涵盖了以下内容: 1. 概述及IOC理论推导 - 这一部分介绍了Spring框架的概述，以及控制反转（IoC）的理论推导。它解释了Spring框架如何通过IoC容器来管理对象的依赖关系，并提供了一些示例来帮助理解这个概念。 引用 2. 使用Spring管理事务 - 这部分讲解了如何使用Spring框架来管理事务。它介绍了如何配置Spring的事务管理器，并通过在方法或类上添加注解来指定事务的边界。此外，还讲解了在Spring中处理事务时需要注意的一些事项。 引用 另外，如果你对狂神的Spring视频感兴趣，可以通过他的B站视频或公众号链接来获取更多相关内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值