526互联

Spring总结

发布时间 2024-01-05 18:09:36作者: 菜鸡前来

Spring框架

1、简介

  • Spring：春天---->给软件行业带来了春天

  • 2002：首次推出了Spring框架的雏形

  • spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布1.0正式版.

  • Rod Johnson,spring framework创始人，很难想象这个人的学历，他学音乐学

  • Spring理念：使现有的技术更加容易使用。他本身就是个大杂烩，整合了现有的技术框架

  • SSH：Struct2+Spring+Hibernate

  • SSM:SpringMVVC+Spring+Mybatis

官网：Spring Framework

官方下载地址：repo.spring.io

GitHub:spring-projects/spring-framework: Spring Framework (github.com)

maven下导入spring依赖

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

2、优点

  • Spring是一个开源的免费的框架（容器）

  • Spring是一个轻量级的，非入侵式的框架

  • 控制反转（IOC），面向切面编程（AOP）（重点）

  • 支持事务的处理，对框架整哈的支持！

总结成一句话：spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架

3、Spring七大模块组成

image-20230302205536415

4、拓展

在spring的官网有这个介绍：现代化的Java开发，说白了介绍基于Spring的开发

  • Spring Cloud

    1. SpringCloud基于SpringBoot实现的

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

5、IOC理论推导

  1. UserDao接口

  2. UserDaoImpl实现类

  3. UserService业务接口

  4. UserServiceImpl业务实现类

我们程序员再也不用去管理对象了，交给用户了，都交给这个Spring容器IOC管理了，系统耦合性大大降低了。

我们使用一个Set接口实现，已经发生了革命性的变化

private UserDao userDao;
​
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

这种思想，从本质上解决了问题，我们程序员不用在去管理对象的创建了，系统的耦合性大大降低，可以更加专注在业务的实现上，这是IOC

6、IOC本质

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

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

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

7. 实践：

helloSpring的创建

步骤：

  1. 添加 Spring Context 依赖包

  2. 创建 spring.xml 配置文件，定义 bean 配置信息

  3. 代码中创建 Spring IoC容器，并从中获取 bean 然后调用

  4. 其中 spring.xml 中是这样定义的 bean：

  • 创建一个maven项目，然后在pojo中创建一个实体类Hello.java

  • 在resources目录下创建bean.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--    使用Spring来创建我们的对象，在spring中都是beans
    bean就相当于帮你new一个对象
    bean标签里面的ID,相当于变量名
    bean标签里面的class，就相当于你调用的实体类
    bean标签里面的property，property中name就相当于给实体类中Spring变量值，property中value就是给变量名赋值
    总结：通俗的来说，就是bean相当于new了一个Hello类的对象，然后通过ID（也就是对象）调用里面的set，get方法
    -->
    <bean id="hello" class="com.lyh.pojo.Hello">
        <property name="str" value="Spring"></property>
    </bean>
​
​
</beans>

  • bean配置有三种，一种是直接配置，一个是交给Factory工厂，还有一个静态的

总结：也就是说，现在我们程序员不用主动去修改代码了，只需要修改一下这个bean.xml文件就可以了。

8.依赖注入：

1.set方法注入

  • 依赖：bean对象的创建依赖于容器

  • 注入：bean对象中的所有属性，由容器来注入

9、Bean的自动装配

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

  • 使用注解自动装配
  1. 环境搭建：
  2. 导入约束
  3. 配置注解支持
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
​
    <context:annotation-config/>
​
</beans>
​

    @Autowired：最重要的，以后开发会经常用

    1. 直接在属性上使用即可，也可以在set方式上使用

    2. 使用Autowired我们可以不用编写set方法了，前提是这个自动装配在IOC容器中存在

    区别：@Resource和@Autowired的区别：

    • 都可以用来自动装配，都可以放在属性字段上

    • @Autowired通过byname的方式实现

    • @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，报错

10、使用注解开发

在spring4之后，要使用注解开发，必须要保证aop的包导入了<依赖>

<!--    这个依赖把spring所有的配置都导进来了-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.2</version>
    </dependency>

使用注解需要导入context约束，增加注解的支持（在applicationContext.xml中配置注解驱动包）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns: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">
​
    <!--    base-package="com.lyh"在这个com.lyh下面的包都扫描，让注解都管用了-->
    <context:component-scan base-package="com.lyh"></context:component-scan>
    <context:annotation-config></context:annotation-config>
​
</beans>
​

  • bean

  • 属性如何注入(@Component)

    package com.lyh.pojo;
​
​
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
​
//（组件）等价于在applicationContext.xml中的 <bean id="user" class="com.lyh.pojo.User"></bean>
@Component
public class User {
    //等价于在applicationContext.xml中的  <property name="name" value="李永辉"></property>
    @Value("李永辉")
    public String name;
}

  • 衍生的注解

    @Component有几个衍生注解，我们在Web开发中，会按照mvc三层架构分层

    1. dao：@Repository

    2. service：@Service

    3. controller：@Controller

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

  • 自动装配

    1. @Autowired：自动装配通过类型--如果Autowired不唯一自动装配属性，则需要

    2. @Qualifier(value="xxx")

    3. @Nullable: 字段标记这个注解，说明这个字段可以为null

    4. Resource：自动装配通过名字类型

  • 作用域

    1. @Scope("scopeName")

    2. @Scope("prototype")

  • 小结

    xml和注解：

    1. xml更加万能，适用于任何场合，维护简单方便

    2. 注解：不是自己的类使用不了，维护相对复杂

    xml与注解最佳实践：

    1. xml用来管理bean

    2. 注解只负责完成属性注入；

    3. 我们使用过程中，只需要注意一个问题，必须让注解生效

      <context:component-scan base-package="com.lyh"></context:component-scan>
<context:annotation-config></context:annotation-config>

（重中之重）注解说明：

  1. @Autowired：自动装配通过类型--如果Autowired不唯一自动装配属性，则需要通过@Qualifier(value="xxx")

2.@Nullable: 字段标记这个注解，说明这个字段可以为null

3.Resource：自动装配通过名字类型

4.@Component（组件），一般放在实体类上面，说明这个类被Spring容器管理了

5.@Value("李永辉")，

//等价于在applicationContext.xml中的 <property name="name" value="李永辉"></property>

11、使用Java的方式配置Spring

相当于全用注解，不用xml文件了

  • 创建maven项目

  • 创建实体类

    package com.lyh.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

//这里这个注解的意思，就是说明这个类已经放到Spring容器接管了，注册到容器中了
@Component
public class User {
    //属性注入值
    @Value("李永辉")
    private String userName;

    public String getUserName() {
        return userName;
    }


    public void setUserName(String userName) {
        this.userName = userName;
    }

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

  • 创建配置类

    package com.lyh.Config;

import com.lyh.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//这个@Configuration也会被容器托管，他的本身就是一个@Component组件
//@Configuration就相当于一个beans.xml文件
@Configuration
public class LiConfig {
    //@Bean相当于bean标签，方法名就是bean标签中的id
    @Bean
    public User user(){
        return new User();//就是返回要注入到bean的对象
    }
}

  • 测试

    import com.lyh.Config.LiConfig;
import com.lyh.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTet {
    public static void main(String[] args) {
        //如果完全使用配置类方式去做，我们就只能通过AnnotationConfig 上下文获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(LiConfig.class);
        User user = (User) context.getBean("user");
         System.out.println(user.getUserName());

    }
}

  • 总结：有可能在SpringBoot框架中，彻底摒弃beans.xml文件用纯Java开发，所以一定要了解。

    1. 注解：

      @Component ：-->这里这个注解的意思，就是说明这个类已经放到Spring容器接管了，注册到容器中了

      @Configuration:-->这个@Configuration也会被容器托管，他的本身就是一个@Component组件

      @Configuration就相当于一个beans.xml文件

      @Bean：-->@Bean相当于bean标签，方法名就是bean标签中的id

12、AOP:代理模式

代理模式的分类：静态代理、动态代理

理解：也就是算是一个中间人（中介），就相当于你租房， 你没有房源，然后你找房子，也就是找中间人中介，所以事情你不需要做，让中介去帮你实现，最终你租到房子；

1、静态代理

  • 优点：

    1. 可以让你的真实角色操作更加纯粹，不在关注公共业务

    2. 公共业务交给代理，实现了业务的分工

    3. 公共业务发生扩展的时候，方便集中管理

  • 缺点：

    1. 一个真实角色就会产出一个代理，代码量增加了

  • 图解

    image-20240104215116133

  • 例解：

    1. 编写UserService接口

      package com.lyh.demo;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    2. 编写UserServiceImpl实现类

      package com.lyh.demo;

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("查询了一个用户");

    }
}

    3. 编写UserServiceProxy类（这个就是切进去的那个类和UserServiceImpl差不多但是我们可以在这里随便修改代码）

      package com.lyh.demo;

public class UserServiceProxy implements UserService{

    private UserServiceImpl userService;

    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 sgm){
        System.out.println("添加了一个日志"+sgm);
    }
}

    4. 测试

      package com.lyh.demo;

public class Test {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
    }
}

2、动态代理

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

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

  • 动态代理的代理类是动态生成的，不是我们注解写好的

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

    1. 基于接口--JDK动态代理

    2. 基于类：

    3. Java字节实现：Javasist

  • 优点：

    1. 可以动态的对service层进行操作，解决了静态代理代理量

  • 代码实现

    1. UserService

      package com.lyh.demo02;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    2. UserServiceImpl

      package com.lyh.demo02;

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("查询了一个用户");

    }
}

    3. 代理工具类ProxyInvocationHandler.java（万能的）

      package com.lyh.demo02;

import com.lyh.demo.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//等会会用这个类自动生成代理类
public class ProxyInvocationHandler 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);
    }
    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String sgm){
        System.out.println("调用了"+sgm+"这个方法");
    }
}

    4. 测试

      package com.lyh.demo02;

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

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

13、AOP

13.1使用Spring实现Aop

  • 第一需要导入一个依赖包

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

  • 使用SpringAop接口

    1. 创建一个maven项目

    2. 添加依赖pom.xml中

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

    3. 编写Spring配置文件，applicationContext.xml

      <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    注册bean-->
    <bean id="userService" class="com.lyh.service.UserServiceImpl"></bean>
    <bean id="log" class="com.lyh.log.Log"></bean>
    <bean id="afterLog" class="com.lyh.log.AfterLog"></bean>
    <!--    配置aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(public void com.lyh.service.UserServiceImpl.add())"/>
        <!--            执行环绕增强
        pointcut-ref切入到那个类中
        -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
    </aop:config>

</beans>

    4. 创建UserService接口、UserServiceImpl实现类

      package com.lyh.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}
      package com.lyh.service;

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("查询了一个用户");

    }
}

    5. 创建Log、AfterLog类

      package com.lyh.log;

import org.springframework.aop.AfterAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //objects：参数
    //o:目标对象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}
      package com.lyh.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为"+o);
    }
}

    注意：Spring实现Aop，在测试类调用的一定是接口，而不是类

13.2、使用注解实现Aop

  • 第一需要导入一个依赖包

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

  • 使用SpringAop接口

    1. 创建一个maven项目

    2. 添加依赖pom.xml中

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

    3. 编写Spring配置文件，applicationContext.xml

      <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    注册bean-->
    <bean id="userService" class="com.lyh.service.UserServiceImpl"></bean>
    <bean id="log" class="com.lyh.log.Log"></bean>
    <bean id="afterLog" class="com.lyh.log.AfterLog"></bean>
<!--    使用注解完成切面-->
    <bean id="annotationType" class="com.lyh.diy.AnnotationType"></bean>
<!--    开启注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!--    &lt;!&ndash;    配置aop&ndash;&gt;-->
<!--    <aop:config>-->
<!--        <aop:pointcut id="pointcut" expression="execution(public void com.lyh.service.UserServiceImpl.add())"/>-->
<!--        &lt;!&ndash;            执行环绕增强-->
<!--        pointcut-ref切入到那个类中-->
<!--        &ndash;&gt;-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>-->
<!--    </aop:config>-->

</beans>

    4. 创建UserService接口、UserServiceImpl实现类

      package com.lyh.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}
      package com.lyh.service;

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("查询了一个用户");

    }
}

    5. 创建AnnotationType类

      package com.lyh.diy;

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

//切面也就是在一个service层中切入进去一个类
//标准这个类是一个切面
@Aspect
public class AnnotationType {

    @Before("execution(public void com.lyh.service.UserService.add())")
    public void before(){
        System.out.println("执行前----------");
    }
    @After("execution(public void com.lyh.service.UserService.add())")
    public void end(){
        System.out.println("切人后");
    }
}
       

    6. 测试：

      import com.lyh.service.UserService;
import com.lyh.service.UserServiceImpl;
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");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

Spring整合Mybatis

回顾Mybatis

  • 编写实体类

    package com.lyh.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
}

  • 编写核心配置文件(Mybatis-spring.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>
    <!--    环境-->
    <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=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--        //写一个mapper.xml配置，得在这里配置一个-->
        <mapper class="com.lyh.dao.UserMapper"/>
    </mappers>
</configuration>

     

  • 编写Mapper接口、Mapper.xml

    package com.lyh.dao;

import com.lyh.pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> selectUser();
}
    <?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=需要绑定一个mapper(dao接口)接口，指定的mapper接口-->
<mapper namespace="com.lyh.dao.UserMapper">
    <!--    select查询语句这里的id对应着接口中方法的名字-->
    <!--    这里就记住resultType和resultMap-->
    <select id="selectUser" resultType="com.lyh.pojo.User" >
        select * from `user`;
    </select>
</mapper>

  • 测试

    import com.lyh.dao.UserMapper;
import com.lyh.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 test() throws IOException {
        String resources="Mybatis-spring.xml";
        InputStream inputStream = Resources.getResourceAsStream(resources);
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

Mybatis-spring

  • 导入相关jar包

    1. junit

    2. mybatis

    3. mysql数据库

    4. spring相关

    5. aop植入

    6. mybatis-spring

  • 编写配置文件

  • 测试

SpringBoot

  • 一个快速开发的脚手脚；

  • 基于SpringBoot可以快速的开发单个微服务。

  • 约束大约配置

SpringCloud

  • SpringCloud是基于SpringBoot的实现的

  •