首页 > 其他分享 >Spring总结

Spring总结

时间：2024-01-05 18:11:07浏览次数：36  
标签：总结 lyh Spring void import com public

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七大模块组成

 

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. 一个真实角色就会产出一个代理，代码量增加了

  • 图解

  • 例解：

    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的实现的

  •  

 

 

 

 

 

 

 

 

 

 

 

 

标签：总结,lyh,Spring,void,import,com,public
From： https://www.cnblogs.com/lyhidea/p/17947804

相关文章

  • springboot 打包本地jar包或外部依赖打不进去问题
    分为两种情况一、打war包的情况引入依赖<dependency><groupId>com.xxxx</groupId><artifactId>xxxxx</artifactId><version>1.0</version><scope>system</scope><systemPath>${basedir}/lib/xxxxx.jar&l......
  • Spring学习记录之手写Spring框架
    Spring学习记录之手写Spring框架前言这篇文章是我第二次学习b站老杜的spring相关课程所进行的学习记录，算是对课程内容及笔记的二次整理，以自己的理解方式进行二次记录，其中理解可能存在错误，欢迎且接受各位大佬们的批评指正；关于本笔记，只是我对于相关知识遗忘时快速查阅了解使用，至......
  • Spring cloud No spring.config.import property has been defined
    *[解决SpringCloud2021.0.5版本，使用nacos做配置中心，报Nospring.config.importpropertyhasbeendefined的问题\_addaspring.config.import=nacos:propertytoyour-CSDN博客](https://blog.csdn.net/weixin_44951259/article/details/127929284)*[SpringCloud202......
  • Springboot 2.7 open api：swagger | knife4j | spring doc
    *[集成SpringDoc接口文档和knife4j|SpringBoot2.7.2实战基础-掘金](https://juejin.cn/post/7201195677128687674)*[Springboot2.7集成Swagger增强版接口框架Knife4j4.3+springdocOpenApi3.0\_knife4jspringboot2.7-CSDN博客](https://blog.csdn.net/Mrqi......
  • 记录Springboot中向企业微信指定人员发送含链接的消息
    背景：从海康智能门禁获取到了进入教室的人脸信息，由此得到一批用户List，等会儿就要实时向这批用户发送消息“***，您已进入**教室，请填写使用情况表<ahref="****">”。  过程：读了微信的开发者文档，摸索着写了测试代码。在debug时，发现微信传来的是{"errcode":60020,"errmsg":"not......
  • 用Spring Boot 3.2虚拟线程搭建静态文件服务器有多快？
    SpringBoot3.2于2023年11月大张旗鼓地发布，标志着Java开发领域的一个关键时刻。这一突破性的版本引入了一系列革命性的功能，包括：虚拟线程：利用ProjectLoom的虚拟线程释放可扩展性，从而减少资源消耗并增强并发性。NativeImage支持：通过NativeImage编译制作速度极快的应......
  • 用 SpringBoot+Redis 解决海量重复提交问题
    1前言在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段：数据库建立唯一性索引，可以保......
  • SpringDataJpa框架使用【超详细！】
    SpringDataJpa框架使用【超详细！】SpringDataJpa框架使用文档一、什么是Jpa?jpa的全称是JavaPersistenceAPI,中文的字面意思就是java的持久层API,jpa就是定义了一系列标准，让实体类和数据库中的表建立一个对应的关系，当我们在使用java操作实体类的时候能达到操作数......
  • MySQL高性能优化规范建议总结
    1、优先选择符合存储需要的最小的数据类型，因为存储字节越小，占用也就空间越小，性能也越好。a.某些字符串可以转换成数字类型存储比如可以将IP地址转换成整型数据。b.对于非负型的数据(如自增ID,整型IP，年龄)来说,要优先使用无符号整型来存储。c.小数值类型（比如年龄、状态表......
  • SpringCloud微服务实战——搭建企业级开发框架（三十二）：代码生成器使用配置说明
    一、新建数据源配置  因考虑到多数据源问题，代码生成器作为一个通用的模块，后续可能会为其他工程生成代码，所以，这里不直接读取系统工程配置的数据源，而是让用户自己维护。参数说明数据源名称：用于查找区分数据源的名称连接地址：连接方式:数据库类型:数据库地址等参数，例：jdbc:m......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99