02-Spring

企业开发 2023-06-21 15:56:54 阅读次数: 0

02-Spring

简介

组成

在这里插入图片描述

拓展

在这里插入图片描述

spring boot

  • 一个快速开发的脚手架
  • 基于spring boot可以快速开发单个微服务
  • 约定大于配置

spring cloud

  • spring cloud是基于spring boot实现的

因为现在大多数公司都在使用spring boot进行快速开发，学习spring boot的前提，需要完全掌握spring以及springMVC。承上启下的作用

IOC理论推导

业务处理流程：

  1. UserDao接口
  2. UserDaoImpl实现类
  3. UserService接口
  4. 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创建对象的方式

在配置文件加载的时候，容器中管理的对象就已经初始化了

  1. 默认使用无参构造创造对象

  2. 有参构造的方式：

    1. 下标赋值

      <bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring">
        <constructor-arg index="0" value="helloSpring"/>
    </bean>

    2. 通过类型赋值

      <bean id="HelloSpring" class="com.XZY_SUNSHINE.pojo.Spring">
        <constructor-arg type="java.lang.String" value="helloSpring"/>
    </bean>

    3. 通过参数名来赋值

      <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中的三种装配方式：

  1. 在xml中显式的配置
  2. 在Java中显式的配置
  3. 隐式的自动装配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&amp;useUnicode=true&amp;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&amp;useUnicode=true&amp;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&amp;useUnicode=true&amp;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);
        }

    }

猜你喜欢

转载自blog.csdn.net/qq_52117201/article/details/129564501
今日推荐
Linus “吃狗粮”最积极！
开源日报 | Winamp播放器即将开源；生成式AI之战升级第二轮；Linus“吃狗粮”最积极；AI进入泡沫前期；吴泳铭为阿里云带来了什么？
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
周排行
LogN级别的区间查询算法(线段树), 你学会了吗
数论概论(英文版.第4版)
idea 更新后和新的直接安装前，都需要配置 idea64.exe.vmoptions 后再使用
CANOpen系列教程04_CAN总线波特率、位时序、帧类型及格式说明
Java序列化基础
java排序算法整理
异常：org.apache.ibatis.reflection.ReflectionException
（算法练习）——二路归并排序
go 闭包函数
好程序员web前端技术分享媒体查询
每日归档
更多
2024-05-21(8)
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022