spring

已于 2022-07-27 21:35:28 修改
阅读量214 收藏
点赞数 1
分类专栏： java 文章标签： spring java 后端
于 2022-07-27 21:24:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Anna_with_mask/article/details/126023114
版权

1、项目创建

1.创建maven项目，spring1

2.导入spring包

<dependencies>
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
</dependencies>

3.创建子项目spring-hellospring

4.pojo文件包，创建一个bean

public class Hello {
    private String str;
    public String getStr() {
        return str;
    }
    @Override
    public String toString() {
        return "hello"+"{str='"+str+'\''+'}';
    }
    public void setStr(String str) {
        this.str = str;
    }
}

5.在resourice下面创建.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.palen.pojo.Hello">
        <property name="str" value="spring"/>
    </bean>

</beans>

注意：property的属性必须有set函数，因为就是靠set注入实现的。此外若属性是引用对象可以用ref。

<bean id="userService" class="service.UserServiceImpl1">
        <property name="userDao" ref="userDao1"/>
</bean>

6.在测试里试一下，mytest中

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.toString());
    }
}

7.输出结果
在这里插入图片描述

思考

  1. hello对象由spring创建
  2. hello对象的属性是有spring容器设置的
  3. hello的对象属性直接去xml文件里配置

这就是控制反转的过程，依赖注入：就是利用set方法进行注入的。

我们不用在程序中去改动，要实现不同操作，只需要在xml配置文件中进行修改，所谓的IOC是一种编程思想，由主动编程变成被动接受，总而言之，对象由spring来创建，管理和装配。

2、Spring配置

1.alias配置别名

参数name里面是bean.xml中有的类名，在用该类时候可以用类名，也可以用别名

    <!--    这里的属性必须得有set函数，才可以进行值注入！！！！！！！！  -->
<bean id="userService" class="service.UserServiceImpl1">
	<property name="userDao" ref="userDao2"/>
</bean>

    <!--    取别名，可以通过类名或者别名-->
<alias name="userService" alias="userServiceNewName"/>

2.Bean配置

在xml文件中配置bean对象

    <!--
        id:唯一标识符
        class：bean对象的所对应的全限定名：包名+类名
        name：别名，可取多个(逗号，分号，空格都可以做分割）
    -->
<bean id="user" class="pojo.User" name="userNewName1,userNewName2">
	<property name="id" value="12"/>
</bean>

3.import配置

	<!--导入其他配置文件-->
<import resource="beans1.xml"/>
<import resource="beans2.xml"/>

用于团队开发，多个配置合并成一个，调用的时候就只用一个总的applicationContext.xml

3、依赖注入DI

IOC: 控制反转思想

定义

依赖注入：应用程序在运行时依赖IOC容器来动态注入组件所需要的某个依赖对象。

  • 依赖：应用程序 依赖 IOC容器（spring、bean工厂）
  • 注入：IOC容器 注入 应用程序某个对象

​ 若没有依赖注入，每个实例对象都要new，new的过程有可能涉及到很多参数的输入，如果每次都需要配置就非常麻烦。因此，采用IOC的思想，把new一个对象的工作交给spring去做，我们需要实例化某个对象的时候，就直接去bean工厂拿该实例对象。

3.1 构造器注入

第一种：通过有参构造函数注入

下标赋值

    <bean id="hello" class="com.palen.pojo.Hello">
        <constructor-arg index="0" value="构造注入，下标创建对象！0表示第一个属性！"/>
    </bean>

类型赋值（但如果属性类型相同，就会出错）

    <bean id="hello" class="com.palen.pojo.Hello">
        <constructor-arg type="java.lang.String" value="构造注入，通过类型来判断属性"/>
    </bean>

属性名称

    <bean id="hello" class="com.palen.pojo.Hello">
        <constructor-arg name="str" value="构造注入，通过属性名称来判断属性"/>
    </bean>

第二种：通过无参构造函数注入，也就是通过set注入

    <bean id="hello" class="com.palen.pojo.Hello">
        <property name="str" value="set注入"/>
    </bean>

3.2 set方式注入（重点）

  • 依赖注入：set注入
    • bean对象创建，依赖容器
    • bean对象的所有属性，由容器注入

例子：

  • student.class（主）、address.class（引用），
  • applicationContext.xml，
  • test.class
package com.palen.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> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", cars=" + cars +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }

    public void setName(String name) {
        this.name = name;
    }
   //...各种get、set方法
}

package com.palen.pojo;
public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

<?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="address" class="com.palen.pojo.Address">
        <property name="address" value="湛江"/>
    </bean>

    <bean id="student" class="com.palen.pojo.Student" name="stu">

        <property name="name" value="小温"/>

        <property name="address" ref="address"/>

        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>三国演义</value>
            </array>
        </property>

        <property name="hobbies">
            <list>
                <value>打羽毛球</value>
                <value>唱歌</value>
            </list>
        </property>

        <property name="cars">
            <map>
                <entry key="宝马" value="粤A8888"/>
                <entry key="奔驰" value="粤A6666"/>
                <entry key="雪佛兰" value="粤A7777"/>
            </map>
        </property>


        <property name="games">
            <set>
                <value>LOL</value>
                <value>跑跑卡丁车</value>
            </set>
        </property>

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

        <property name="info">
            <props>
                <prop key="学号">1815200243</prop>
                <prop key="身份证">11020312220231</prop>
                <prop key="性别">男</prop>
            </props>
        </property>

    </bean>

</beans>

import com.palen.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student stu = (Student)context.getBean("stu");
        System.out.println(stu.toString());

    }
}

在这里插入图片描述

3.3 其他注入

p命名空间注入 ：xmlns:p=“http://www.springframework.org/schema/p”

实际就是简化了属性值注入，注意一定要有set函数

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

    <!--    p命名空间注入，直接注入属性值-->
    <bean id="user" class="com.palen.pojo.User" p:name="小温" p:age="18"/>
</beans>

c命名空间注入：xmlns:c=“http://www.springframework.org/schema/c”

实际就是简化了参数构造注入，注意一定要有构造函数

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       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="user2" class="com.palen.pojo.User" c:_0="妹" c:_1="18"/>
</beans>

4、Bean自动装配

  1. 自动装配是spring满足bean的依赖一种方式

  2. spring会在上下文自动寻找，自动给bean装配属性

  3. bean有三种装配：xml显示装配、java显示装配、隐示自动装配（重点）

    《spring实战》中给装配下了一个定义：创建应用对象之间协作关系的行为称为装配。也就是说当一个对象的属性是另一个对象时，实例化时，需要为这个对象属性进行实例化。这就是装配。

4.1 xml显示装配

前面几节学的都是xml显示装配bean的过程（略）

    <bean id="people" class="com.palen.pojo.People">
        <property name="name" value="yvonne"/>
        <property name="dog" ref="dog5555"/>
        <property name="cat" ref="cat"/>
    </bean>

4.2 java显示装配

第一种：autowire=“byName” 会在容器上下文中查找，和自己对象set方法后面的值对应的bean-id

<!-- autowire="byName" 会在容器上下文中查找，和自己对象set方法后面的值对应的bean-id   -->
<bean id="people" class="com.palen.pojo.People" autowire="byName">
    <property name="name" value="yvonne"/>
</bean>

第二种：autowire=“byType” 会在容器上下文中查找，和自己对象属性类型相同的bean

<!-- autowire="byType" 会在容器上下文中查找，和自己对象属性类型相同的bean  -->
<bean id="dog5555" class="com.palen.pojo.Dog"/>  
<bean id="people" class="com.palen.pojo.People" autowire="byType">
	<property name="name" value="yvonne"/>
</bean>

小结：

  1. byname需要保证bean的id唯一且bean需要和自动注入的属性的set方法的值一致
  2. byType需要保证bean的class唯一且bean需要和自动注入的属性的set方法的值一致

4.3 使用注解装配（重点）

4.3.1 @Autowired注解步骤

1.People.class 引用了Dog.class Cat.class，使用@Autowired注解

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private  Dog dog;
    private String name;
    
}

2.beans.xml中，只需要写好bean-id，以及配置

<?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
                           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/>
    <bean id="cat" class="com.palen.pojo.Cat"/>
    <bean id="dog" class="com.palen.pojo.Dog"/>
    <bean id="people" class="com.palen.pojo.People" />
</beans>

3.在test中使用即可。

4.3.2 小结

  • @Autowired可以在属性或者set方法上使用
  • @Autowired注解后可以不用set方法注入，前提是自动装配的属性在IOC容器中(这里指Peopole的cat和dog属性都在IOC容器中)
  • @Autowired(required = false) ：表示该属性可以为空
  • @Autowired是先byType，再byName(指先查找该属性相同类型的bean，若有多个，找同名的bean)

4.3.3 扩展

  • @Nullable ：标记这个注解表示这个字段可以为空
  • @Resource：类似@Autowired注解，是javax里面的注解，但区别是先byName，后byType
  • @Qualifier用于显示定义属性对应容器中bean-id，配合@Autowired使用
@Autowired
@Qualifier(value = "cat222222") //  beans中    <bean id="cat222222" class="com.palen.pojo.Cat"/>
private Cat cat;

5、注解开发（过程）

在spring4之后，aop包必须导入

5.1 注解说明

注解说明
@Autowired自动装配，通过类型，名称
@Qulifier(value=“xxx”)配合Autowired来装装配
@Nullable属性可为null
@Resource自动装配（java自带）
@Component说明该类是bean，说明该类被管理
@Value注入属性
@Scopebean范围

5.2 注解开发步骤

  1. bean

    @component

    等价于 在xml中写

  2. 属性注入

    @Component
public class User {
    @Value("palen")
    public String name;
}

  3. 衍生注解

    在web分层中，各个层功能一样，加了注解说明都是组件，都被类管理

    • pojo:@component

    • dao:@Repostory

    • service:@Service

    • controller:@Controller

  4. 自动装配

    • @Autowired

    • @Qulifier(value=“xxx”)

    • @Nullable

    • @Resource

  5. 作用域

    • @Scope(“prototype”)
    • @Scope(“singleton”):单例子

  6. 小节

    xml与注解都可以

    xml更加万能，适用任何场合，维护简单。

    注解不是自己类使用不了，维护难。

    市场上大多：xml用来管理bean，注解用于属性注入。

6、使用java方式配置spring

意思是不用xml来实现，全程交给java做

JavaConfig，在spring4成为核心

1.实体类pojo

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

    public String getName() {
        return name;
    }

    @Value("palen")
    public void setName(String name) {
        this.name = name;
    }


    private String name;
}

2.配合类config

@Configuration
public class MyConfig {

    /*
    * xml中bean的id对应这里的getUser；class对应这里的返回类
    * */

    @Bean
    public User getUser(){
        return new User();
    }

}

7、代理模式

SpringAOP的底层就是代理模式。

代理模式：静态代理和动态代理

7.1 静态代理

7.1.1 静态代理分析

角色分析

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  • 客户：访问代理的对象

代码步骤

  1. 接口
  2. 真实角色
  3. 代理角色
  4. 客户

7.1.2 租房例子

未代理前:客户找房东实现租房

在这里插入图片描述

在这里插入图片描述

静态代理后：

在这里插入图片描述

在这里插入图片描述

7.1.3 增删查改例子

未代理前：
在这里插入图片描述

增加代理角色后：

在这里插入图片描述

正常开发流程是dao-service-controller-前端，然后后期要横向要增加某个功能或者操作的时候，就可以使用代理思想去实现。

在这里插入图片描述

7.1.4 静态代理好坏处

好处：

  • 使真实角色操作更加纯粹，不用关注其他一些公共业务
  • 公共也就交给代理角色，实现业务的分工
  • 公共业务发送扩展的时候，方便集中管理

缺点：

  • 一个真实角色就会产生一个代理角色；代码量会翻倍

7.2 动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的
  • 动态代理分为两大类：基于接口的动态代理、基于类的动态代理
    • 基于接口-----jdk代理
    • 基于类--------cglib
    • java字节码----javassit

Proxy：代理，InvocationHandler：调用处理程序

7.2.1 租房例子

在这里插入图片描述

7.2.2 增删查改例子

在这里插入图片描述

7.2.3 态代理好处

  • 使真实角色操作更加纯粹，不用关注其他一些公共业务
  • 公共也就交给代理角色，实现业务的分工
  • 公共业务发送扩展的时候，方便集中管理
  • 一个动态代理类代理的是一个接口，对应的是一类的业务
  • 一个动态代理类可以代理多个类，只要实现了同一个接口即可

8、AOP

8.1 什么是AOP？

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

名词解释
切面（Aspect）切面是通知和切点的结合。
连接点（join point）连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。
通知（Advice）AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。
目标对象（Target）目标对象指将要被增强的对象。
切点（PointCut）可以插入增强处理的连接点。
引入（Introduction）引入允许我们向现有的类添加新的方法或者属性。
织入（Weaving）将增强处理添加到目标对象中，并创建一个被增强的对象，这个过程就是织入。
顾问（Advisor）顾问是Advice的一种包装体现，Advisor是Pointcut以及Advice的一个结合，用来管理Advice和Pointcut

spring支持的5中Advice：

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

需要导的包

 <!--导入切入点的表达式的依赖jar包-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

8.2 方法一：使用Spring的API接口

在这里插入图片描述

8.3 方法二：自定义类

在这里插入图片描述

8.4 way1、2两者对比

在这里插入图片描述

8.5 方法三：注解实现

注解：

  • 切面@Aspect
  • 通知@Before、@After

在这里插入图片描述

9、整合mybatis

步骤

  1. 导入相关jar包

    1. junit
    2. mybatis
    3. mysql
    4. spring相关
    5. aop织入
    6. mybatis-spring【new】
        <dependencies>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.29</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--spring-mvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.21</version>
        </dependency>

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

        <!--aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9.1</version>
            <scope>runtime</scope>
        </dependency>

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

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <!-- 防止maven过滤掉xml文件 -->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
    <!-- xml文件中也能中文注解 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

  2. 编写配置文件

  3. 测试

9.1 回忆mybatis

  1. 编写实体类User

    package com.palen.pojo;

import lombok.Data;

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

  2. 编写核心配置文件mybatis-config.xml

    <?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核心配置文件-->
<configuration>

    <!--  起别名  -->
    <typeAliases>
        <package name="com.palen.pojo"/>
    </typeAliases>

    <!--链接数据库-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/><!--amp;为转义字符-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--每一个mapper.xml都需要mybatis核心配置文件中注册    -->
    <mappers>
        <mapper class="com.palen.mapper.UserMapper"/>
    </mappers>

</configuration>

  3. 编写接口UserMapper

    package com.palen.mapper;
import com.palen.pojo.User;
import java.util.List;

public interface UserMapper {
    //查询用户
    public List<User> queryUser();
}

  4. 编写mapper.xml

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

<!--namespace绑定一个对应的dao/mapper-->
<mapper namespace="com.palen.mapper.UserMapper">
    <!--查询语句-->
    <select id="queryUser" resultType="user">
       select * from mybatis.user;
   </select>
</mapper>

  5. 测试

    import com.palen.mapper.UserMapper;
import com.palen.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class MyTest {
    @Test
    public void queryUserTest() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resources);

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

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

6.总：
在这里插入图片描述

9.2 spring整合mybatis方法一

9.2.1 操作步骤

  1. 编写数据源配置DataSource
  2. sqlSessionFactory
  3. sqlSessionTemplate
  4. 需要给接口加实现类
  5. 将自己写的实现类，注入到sprig中
  6. 测试使用即可

9.2.2 具体操作

1.UserMapper.java(interface接口)

public interface UserMapper {
    //查询用户
    public List<User> queryUser();
}

2.UserMapper.xml

​ 实现一些与UserMapper.java(interface接口)数据库操作相关的sql语句

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

<!--namespace绑定一个对应的dao/mapper-->
<mapper namespace="com.palen.mapper.UserMapper">
    <!--查询语句-->
    <select id="queryUser" resultType="user">
       select * from mybatis.user;
   </select>
</mapper>

3.UserMapperImpl.java

​ 实现UserMapper.java(interface接口)，整合spring-mybatis需要实现类

public class UserMapperImpl implements UserMapper {

    //所有操作都使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
	
    //实现接口UserMapper方法
    public List<User> queryUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.queryUser();
    }
}

4.spring-dao.xml：

  1. 配置mybatis的datesource
  2. 配置sqlSessionFactory（注册mapper.xml文件、绑定mybatis.xml文件）
  3. 配置sqlSessionTemplates（即sqlSession）
  4. 注册mapperImpl实现类
<?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 -->
        <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?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false"/>
            <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"/>
            <!-- 注册mapper -->
            <property name="mapperLocations" value="classpath:com/palen/mapper/*.xml"/>
        </bean>

        <!-- 官方推荐用SqlSessionTemplate -->
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <!-- 用构造参数方法注入属性sqlSessionFactory-->
            <constructor-arg index="0" ref="sqlSessionFactory"/>
        </bean>


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

</beans>

在这里插入图片描述

5.mybatis-config.xml

​ 用于mybatis配置（整合spring后，datesource等在spring里配置，即在spring-dao.xml配置），因此这块比较干净，甚至可以不要，有只是为了说明我整合了mybatis。

<?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核心配置文件-->
<configuration>

    <!--  起别名  -->
    <typeAliases>
        <package name="com.palen.pojo"/>
    </typeAliases>


</configuration>

6.applicationContext.xml

​ 用于整合所有xml文件，以后不仅整合mybatis的，还有可能整合mvc（若当前不整合mvc，也可以不要这个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-dao.xml专注做mybatis的配置-->
    <import resource="spring-dao.xml"/>

</beans>

7.测试MyTest.java

​ 用于获取上下文context，并从中获得usermapper这个bean对象，并且使用。

import com.palen.mapper.UserMapper;
import com.palen.pojo.User;
import org.apache.ibatis.io.Resources;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;

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

9.3 spring整合mybatis方法二

9.3.1 操作步骤

  1. 编写数据源配置DataSource
  2. sqlSessionFactory
  3. 需要给接口加实现类继承SqlSessionDaoSupport
  4. 将自己写的实现类，注入到sprig中
  5. 测试使用即可

9.3.2 具体步骤

1.UserMapper.java(interface接口)

public interface UserMapper {
    //查询用户
    public List<User> queryUser();
}

2.UserMapper.xml

​ 实现一些与UserMapper.java(接口)数据库操作相关的sql语句

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

<!--namespace绑定一个对应的dao/mapper-->
<mapper namespace="com.palen.mapper.UserMapper">
    <!--查询语句-->
    <select id="queryUser" resultType="user">
       select * from mybatis.user;
   </select>
</mapper>

3.UserMapperImpl.java(较方法一改动)

​ 实现UserMapper.java(interface接口)方法，并且继承SqlSessionDaoSupport直接提供SQLSession

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    //实现接口方法
    public List<User> queryUser() {
        return getSqlSession().getMapper(UserMapper.class).queryUser();
    }
}

4.spring-dao.xml(较方法一改动)

  1. 配置mybatis的datesource
  2. 配置sqlSessionFactory（注册mapper.xml文件、绑定mybatis.xml文件）
  3. 注册mapperImpl实现类(注入父类需要的参数sqlSessionFactory)
<?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 -->
        <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?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false"/>
            <property name="username" value="root"/>
            <property name="password" value="12345"/>
        </bean>

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

        <!-- 注册UserMapperImpl -->
        <bean id="userMapper" class="com.palen.mapper.UserMapperImpl2">
            <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
        </bean>

</beans>

5.mybatis-config.xml

​ 用于mybatis配置（整合spring后，datesource等在spring里配置，即在spring-dao.xml配置），因此这块比较干净，甚至可以不要，有只是为了说明我整合了mybatis。

<?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核心配置文件-->
<configuration>

    <!--  起别名  -->
    <typeAliases>
        <package name="com.palen.pojo"/>
    </typeAliases>


</configuration>

6.applicationContext.xml

​ 用于整合所有xml文件，以后不仅整合mybatis的，还有可能整合mvc（若当前不整合mvc，也可以不要这个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-dao.xml专注做mybatis的配置-->
    <import resource="spring-dao.xml"/>

</beans>

7.测试MyTest.java

​ 用于获取上下文context，并从中获得usermapper这个bean对象，并且使用。

import com.palen.mapper.UserMapper;
import com.palen.pojo.User;
import org.apache.ibatis.io.Resources;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;

public class MyTest {
    @Test
    public void spring_mybatis_test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        List<User> userList = userMapper.queryUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}
Yvonne_3528
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Spring】——Spring的创建与使用
冷兮雪的博客
06-03 4814
上期我们讲解了Spring是什么及Spring的核心特点，其中重点讲解了控制反转（IoC）和依赖注入（DI），下面我们通过示例代码来去更深刻了解这其中的含义。
spring源码分析之ApplicationContext
热门推荐
liushangzaibeijing的博客
07-18 6万+
本篇博文主要针对ApplictionContext的功能进行详细的解释说明，主要的实例是以ClassPathApplicationContext为主进行介绍了，核心分析了ApplicationContext在启动过程中做的一些操作，比如容器刷新准备，调用BeanFactory后置处理器，注册bean后置处理器，国际化，事件监听，容器创建结束的lifycecly的启动等，需要通过这篇文章能帮助大家很好理解ApplicationContext体系的相关知识点，让读者更好的理解spring的相关源码。
Spring学习笔记
m0_61689010的博客
10-24 96
Spring框架是由软件开发的复杂性而创建的，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建。---百度百科 Spring框架由以下的模块构成，一一进行学习。 1、IOC容器 1.1之前Java代码的学习中，创建对象常常通过new构造器的方式实现。随着业务不断的复杂，代码量不断增加，有时候new的方式不太方便。这时候，可以使用Spring中IOC容器进行实例化对象。 ...
java 代码中util包,java.util包问题
weixin_32629853的博客
03-11 448
java.util包问题import java.text.*;import java.util.*;class PersonTest /*这里为什么不能加public啊*(书上的有加 但我打上编译时出错*/{public static void main(String args []){Person[] people =new Person[2];people[0]=new Employee(...
JAVA中如何统计变量值的个数,JAVA如何统计人数(接着下面的程序写)
weixin_29421255的博客
03-21 1156
建一个test1的类就可以跑了import java.util.*;public class test1 {public static void main(string[] args) {list stus=new arraylist();for(int i=1;i<=100;i++){//按你要求100人stus.add(new stu(i));}int peop = stus.size(...
SpringCloud视频教程全套百度网盘
03-01
第1章 SpringCloud简介 第2章 SpringCache缓存详细讲解及应用 第3章 Redis高级缓存讲解及应用 第4章 SpringSecurity安全详细讲解及应用 第5章 RabbitMQ高级消息的讲解及应用 第6章 ElasticSearch详细讲解及应用 第7...
spring-ai-core 0.8.1
最新发布
05-21
《Spring AI Core 0.8.1：开启人工智能之旅》 在现代软件开发领域，Spring框架以其强大的功能和灵活性，已经成为Java开发中的首选框架之一。而Spring AI Core则是Spring生态系统中专门为人工智能（AI）和机器学习...
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
import.java.util,java的一段代码
weixin_32029321的博客
03-11 1011
import java.util.*;public class Student implements Comparator,Comparable{private String name;primport java.util.*;public class Student implements Comparator,Comparable{private String name;private int ...
java compare接口_Java : Comparable 和 Comparator 接口
weixin_39784460的博客
02-16 243
对象排序例如我已经有如下的 Person 类，该类具有 name 和 age 2 个属性，现在我们需要对存放 Person 类的数组或集合进行排序。此时有很多的排序策略，例如对 age 按升序或降序排序，或堆 name 按字典序排序，也可以先按 age 进行排序后对 age 属性相同的对象按 name 的字典序排序。class Person{private String name;private ...
JDK8的新特性
qq_59114219的博客
07-23 245
详细介绍lambda表达式和使用 函数式接口 方法引用 Stream流 新增日期类
java set import_importjava.util.Set;importjava.u? 爱问知识人
weixin_30667831的博客
02-16 158
import java.util.Set ;import java.util.HashSet ;class Person{private String name ;private int age ;public Person(String namimport java.util.Set ;import java.util.HashSet ;class Person{private String n...
Java 泛型高级编程 ? 类型占位符的使用
天上满是飞机
10-27 2604
import java.util.*; class Person { private String name; private int age; public Person (String name,int age) { this.name=name; this.age=age; } public String getName() { return
使用lombok插件说明
记事本
12-27 1014
Lombok简介 Project Lombok makes java a spicier language by adding ‘handlers’ that know &gt;how to build and compile simple, boilerplate-free, not-quite-java code. github上官方是这么描述lombok的：          lom...
#Java学习#习题三
vircorns的博客
05-25 1万+
文章目录判断题单选题函数题写出派生类构造方法（Java）根据派生类写出基类（Java）人口统计编程题通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数数组元素交换集体评分jmu-Java-03面向对象基础-01-构造函数与toString 判断题 单选题 函数题 写出派生类构造方法（Java） 裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行 函数接口定义: 根提示： 观察类
lombok安装及使用
qq_36335126的博客
10-26 1051
常用的 lombok 注解： @Data ：注解在类上；包含了@ToString，@EqualsAndHashCode，@Getter / @Setter和@RequiredArgsConstructor的功能，提供类所有属性的 getter 和 setter 方法，此外还提供了equals、canEqual、hashCode、toString 方法 @Setter：注解在属性上；为属性提供 setter 方法 @Getter：注解在属性上；为属性提供 getter 方法 @ToString：注解在类上
超详细IDEA配置SSM环境
易龙杨Longyang Yi的博客
06-02 6381
IDEA搭建SSM开发环境，超详细！spring、spring mvc、mybatis

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值