Spring框架总结

G-Vict

已于 2022-10-13 19:59:05 修改

阅读量485

点赞数 1

分类专栏： java 框架 Spring 文章标签： spring java

于 2022-10-13 19:52:17 首次发布

本文链接：https://blog.csdn.net/gaowen0813/article/details/127276931

版权

java 同时被 3 个专栏收录

4 篇文章 0 订阅

订阅专栏

框架

1 篇文章 0 订阅

订阅专栏

Spring

1 篇文章 0 订阅

订阅专栏

spring等框架个人总结

spring框架
SpringMVC
- SpringMVC常用注解
- Spring MVC的执行流程
MyBatis
- mybatis快速进行持久层的开发
- Mybatis Plus
Spring Boot JPA

spring框架

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）
Spring框架包含众多模块，如Core、Testing、Data Access、Web Servlet等，其中Core是整个Spring框架的核心模块。Core模块提供了IoC容器、AOP功能、数据绑定、类型转换等一系列的基础功能，而这些功能以及其他模块的功能都是建立在IoC和AOP之上的，所以IoC和AOP是Spring框架的核心。

主要特点

IOC ，IoC（Inversion of Control）是控制反转的意思，这是一种面向对象编程的设计思想。在不采用这种思想的情况下，我们需要自己维护对象与对象之间的依赖关系，很容易造成对象之间的耦合度过高，在一个大型的项目中这十分的不利于代码的维护。IoC则可以解决这种问题，它可以帮我们维护对象与对象之间的依赖关系，降低对象之间的耦合度。
DI，DI（Dependency Injection），DI是依赖注入的意思，它是IoC实现的实现方式，就是说IoC是通过DI来实现的。由于IoC这个词汇比较抽象而DI却更直观，所以很多时候我们就用DI来代替它，在很多时候我们简单地将IoC和DI划等号，这是一种习惯。而实现依赖注入的关键是IoC容器，它的本质就是一个工厂。
AOP，AOP（Aspect Oriented Programing）是面向切面编程思想，这种思想是对OOP的补充，它可以在OOP的基础上进一步提高编程的效率。简单来说，它可以统一解决一批组件的共性需求（如权限检查、记录日志、事务管理等）。在AOP思想下，我们可以将解决共性需求的代码独立出来，然后通过配置的方式，声明这些代码在什么地方、什么时机调用。当满足调用条件时，AOP会将该业务代码织入到我们指定的位置，从而统一解决了问题，又不需要修改这一批组件的代码。
bean: java类型，由spring框架创建的对象，就被称为bean . (pojo: 纯java类（私有的属性，公开的get/set方法这种类。）)

对Spring容器的了解

Spring主要提供了两种类型的容器：BeanFactory和ApplicationContext。

BeanFactory：是基础类型的IoC容器，提供完整的IoC服务支持。如果没有特殊指定，默认采用延迟初始化策略。只有当客户端对象需要访问容器中的某个受管对象的时候，才对该受管对象进行初始化以及依赖注入操作。所以，相对来说，容器启动初期速度较快，所需要的资源有限。对于资源有限，并且功能要求不是很严格的场景，BeanFactory是比较合适的IoC容器选择。
ApplicationContext：它是在BeanFactory的基础上构建的，是相对比较高级的容器实现，除了拥有BeanFactory的所有支持，ApplicationContext还提供了其他高级特性，比如事件发布、国际化信息支持等。ApplicationContext所管理的对象，在该类型容器启动之后，默认全部初始化并绑定完成。所以，相对BeanFactory来说，ApplicationContext要求更多的系统资源，同时，因为在启动时就完成所有初始化，容器启动时间较之BeanFactory也会长一些。在那些系统资源充足，并且要求更多功能的场景中，ApplicationContext类型的容器是比较合适的选择。

Spring的使用

1.导入框架需要的jar包（加依赖）

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

2.创建spring框架的xml文件（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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- id: 给bean设置的唯一标志， 可以通过id ，找到这个bean对象
class: 类的全名，用于表示bean的类型。
*** 如果没有指定使用某个构造函数，那么默认用无参构造函数
-->
<bean id="p1" class="com.hqyj.entity.Phone"></bean>
</beans>

3.定义一个java类，然后在spring的xml文件中配置bean对象

<!-- 注意提供无参构造函数-->
public class Phone {
private String pinPai; // 品牌
private Double price ; // 价格
private Integer mem ; // 内存
// get/set方法
}

spring.xml中bean的配置

<bean id="p1" class="com.hqyj.entity.Phone"></bean>

4.创建spring的容器，然后在容器中获取对象，使用对象

@Test
public void getPhone(){
// 1. 创建出spring的容器对象
ApplicationContext ac =
new ClassPathXmlApplicationContext("springday1.xml" );
System.out.println("ac:" + ac);
// 2. 通过容器对象，获取bean。
// getBean(bean的id, bean的类型)
// Phone p1 = ac.getBean("p1", Phone.class);
// Object p1 = ac.getBean("p1");// 根据id查找，但是没有设置查找的结果的类型，所以
返回Object.
Phone p1= ac.getBean(Phone.class); //根据bean的类型查找， 如果有多个符合条件的
类型，就出错。
// 3. 使用对象
p1.setPinPai("vivo");
System.out.println(p1.getPinPai());
// *** 类型
System.out.println(Phone.class); //class com.hqyj.entity.Phone
System.out.println(ApplicationContext.class); //interface
org.springframework.context.ApplicationContext
System.out.println(p1.getClass());//class com.hqyj.entity.Phone
// --- 编译的时候 ac看引用的类型，是ApplicationContext接口。
// --- 程序运行的时候， ac看实际指向的对象的类型， 是
ClassPathXmlApplicationContext类
System.out.println(ac.getClass());//class
org.springframework.context.support.ClassPathXmlApplicationContext
// if(p1.getClass()== Phone.class) ： 判断是否为同一种类型
// 4. 容器关闭
}

spring配置

1.bean标签的属性设置

id : bean的唯一标志
class ：bean的类型
factory-method ：调用工厂方法，创建对象
factory-bean ：调用创建对象的bean ，然后再factory-method 设置需要调用的具体的方法。

2.bean的作用范围
bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）

1.scope属性：常用 singleton,prototype

singleton：单例的（默认值）当加载配置文件时，就会创建对象。
prototype：多例的（当getBean时才会创建对象）
request：每次HTTP请求都会创建一个新的Bean。
session：同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean。

<bean id="test" class="com.hqyj.entity.Phone" scope="prototype"></bean>
<bean id="test1" class="com.hqyj.entity.Phone" scope="singleton"></bean>

2.生命周期-初始化方法和销毁方法的设置

自定义初始化方法，并在该方法前增加@PostConstruct注解，届时Spring容器将在调用SetBeanFactory方法之后调用该方法。
自定义销毁方法，并在该方法前增加@PreDestroy注解，届时Spring容器将在自身销毁前，调用这个方法。

<!-- init-method="init" : 创建对象的时候，执行init方法，
destroy-method="destroy" ： 容器关闭，bean对象就调用其destroy方法
默认：scope="singleton"
lazy-init: 设置bean的创建时机，默认是false.
* true: 表示当需要第一次使用这个对象的时候，才创建这个对象
* false: 表示创建spring的容器的时候，就创建对象。
-->
<bean id="example" class="com.hqyj.entity.ExampleBean"
init-method="init" scope="prototype"
destroy-method="destroy"></bean>
</beans>

spring注入方式

1.setter方法注入（值类型用value注入、引用类型用ref注入）
2.构造方法注入
3.p名称空间注入—实际上set注入，spring特有，为了简化property写法

spring整合junit

1.导junit包

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.3.21</version>
</dependency>

2.定义方法
3.测试

@RunWith(SpringJUnit4ClassRunner.class) // 测试相关类的引入
@ContextConfiguration("classpath:springday3.xml") // 告知spring的容器对象，需要
加载的spring配置文件的路径
public class TestStu {
	@Autowired // 自动装配
	Student stu ;
	@Autowired
	Student1 stu1;
	@Autowired
	List<String> list;
	@Test
	public void test1(){
		System.out.println(list);
		Assert.assertNotNull(list);
	}
	@Test
	public void testC(){
	// System.out.println(stu);
	System.out.println("stu1:" + stu1);
	}
}

SpringMVC

springmvc是spring框架的一个模块
springmvc和spring无需通过中间整合层进行整合。
springmvc是一个基于mvc的web框架。
M：model，模型层，模型就是数据
V：view，网页、jsp，显示数据
C：controller，控制层，控制器的作用就是把不同的数据(Model)，显示在不同的视图(View)上，Servlet 扮演的就是这样的角色。

SpringMVC常用注解

@Controller

@Controller
//1.spring容器创建对象。 
//2. spring容器知道这个类是Controller类型。
public class ThirdController {
}

@RequestMapping(可以设置请求方式，不设置的话，所有请求方式都支持)

@RequestMapping("/add") // 省略了value属性
public String add2(){
System.out.println("requestMapping .....");
return "success";
}

@RequestParam

//@RequestParam(value = "eno",required = true ,defaultValue = "1000")
// --- value ,表示对应url地址中参数的key。目的是把url中的参数和方法的参数名对应。
// --- required ，表示要求方法的参数不能是null.
// --- defaultValue , 如果url地址中没有这个参数，那么方法的参数就是设置这个默认值。
@RequestMapping("/update1") // http://localhost:8080/springmvc1/emp/update1?
eno=100&ename=xiaohong
public String update1(@RequestParam(value = "eno",required = true
,defaultValue = "1000") Integer eid
,@RequestParam(value = "ename") String name){
System.out.println("eid:" + eid);
return "success";
}

Spring MVC的执行流程

1.整个过程开始于客户端发出的一个HTTP请求，Web应用服务器接收到这个请求。如果匹配DispatcherServlet的请求映射路径，则Web容器将该请求转交给DispatcherServlet处理。

2.DispatcherServlet接收到这个请求后，将根据请求的信息（包括URL、HTTP方法、请求报文头、请求参数、Cookie等）及HandlerMapping的配置找到处理请求的处理器（Handler）。可将HandlerMapping看做路由控制器，将Handler看做目标主机。值得注意的是，在Spring MVC中并没有定义一个Handler接口，实际上任何一个Object都可以成为请求处理器。

3.当DispatcherServlet根据HandlerMapping得到对应当前请求的Handler后，通过HandlerAdapter对Handler进行封装，再以统一的适配器接口调用Handler。HandlerAdapter是Spring MVC框架级接口，顾名思义，HandlerAdapter是一个适配器，它用统一的接口对各种Handler方法进行调用。

4.处理器完成业务逻辑的处理后，将返回一个ModelAndView给DispatcherServlet，ModelAndView包含了视图逻辑名和模型数据信息。

5.ModelAndView中包含的是“逻辑视图名”而非真正的视图对象，DispatcherServlet借由ViewResolver完成逻辑视图名到真实视图对象的解析工作。

6.当得到真实的视图对象View后，DispatcherServlet就使用这个View对象对ModelAndView中的模型数据进行视图渲染。

7.最终客户端得到的响应消息可能是一个普通的HTML页面，也可能是一个XML或JSON串，甚至是一张图片或一个PDF文档等不同的媒体形式。

MyBatis

MyBatis 是一款半自动的ORM持久层框架，具有较高的SQL灵活性，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，但它的数据库无关性较低
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

mybatis快速进行持久层的开发

编写全局配置文件
编写mapper映射文件
加载全局配置文件，生成SqlSessionFactory
创建SqlSession，调用mapper映射文件中的SQL语句来执行CRUD操作

Mybatis Plus

mybatis虽然简便，但需要编写大量的SQL语句，然而mybatis plus是一个为了简化开发，提高效率的mybatis增强工具，为了简化开发，提高效率。

Spring Boot JPA

JPA即Java Persistence API，它是一个基于O/R映射的标准规范。也就是说它指定以了标准规则，不提供实现，软件提供商可以按照标准规范来实现，而使用者只需按照规范中定义的方式来使用，不用和软件提供商打交道。JPA主要实现有Hibernate、EclipseLink、OpenJPA等，我们使用JPA来开发，无论是采用哪一种实现方式都一样。