Spring框架

 概论:这一部分主要是讲解当前公司中所使用的技术、框架.

为什么要学习框架,举个例子:走一条道我们走山路是1个小时到达,但是走高速公路就是20分钟到达.走两条路所要花销都是一致的,而且走高速公路还可以使用公路的配套设施(比如服务站加油站之类的,而走山路只能走自己的路),此时我们大多数人都会选择走高速公路.

分析一下servlet的痛点:

1. 添加外部的jar不方便,容易出错,比如添加了一个不匹配的外部的jar版本.

2. 运行和调试的时候需要配套tomcat不方便.

3. 发布不方便servlet项目必须依靠外置的tomcat(外置的web容器)运行.

4. 路由器配置不方便,一个访问地址对应一个servlet类

所以此处我们就使用当前全球最为流行的spring框架进行servlet的替代,让编程能够更加的高效,简单,且能够实现更多的功能.

spring的定义:包含了众多工具的IoC容器.

什么是Ioc:

IoC就是(控制反转)

比如制造一辆汽车,

车 -> 车身 -> 框架 -> 轮胎/发动机

车的制作的每一步流程都是依托于前一步流程的,不可分开.

但是这样制造汽车会影响开发速率,并且流程中的耦合性太高,如果前一步出错(如框架有问题),之后的流程就都会收到影响.

而如今生产汽车引入了流水线,分别制造各个组件.就节省了生产成本,与开发时间.

并且汽车各个部分的组件也可以进行客制化定制.(想要怎样的零件就生产怎样的零件)

ioc其实就相当于现在流水线.不在关注该类的依赖,而是把自己这个类的生命周期交给别的流程让其控制.就相当于将我们每个类的生命周期交给spring,让spring去控制依赖这样可以极大程度上的解耦合.

所以说IoC不是一个具体的技术,是一个思想(就是相当于把自己类的生命周期交给别的类来使用的一种思想)

 怎么理解spring的定义:包含了众多工具的IoC容器.

spring既然是一个容器,故定然有两个功能:

1.存对象

2.取对象

所以说我们要学习的东西也就明确是:存对象和取对象

Spring IoC 优点:

1. 解耦

2. 使用更加方便了(不需要手动进行创建,和关注这个对象背后的关系了)

3. 更加高效

DI的概念:

DI就是(依赖注入)

IoC和DI是一对cp,一般都是同时出现且存在的.

DI(依赖注入)就是在IoC过程中,将依赖的某个对象动态注入(动态拿到当前类当中)的这个行为.

所以说DI就是在主动获取对象.(主要实现方式其实就是一个注解)

所以说IoC( 思想 ) / Spring IoC( 框架 ) / DI( 技术 )

一、安装spring boot 简单方式:

首先寻找一份免费的和你idea版本对应的intellij-spring-assistant-2022.1.2.zip

然后这样添加:

寻找安装包:

然后重启idea就安装好了:

创建项目:

主要就是改一下maven

选择maven版本

添加javaweb:

这样就创建成功了:

另外创建的目录都是这个意思:

二、spring的创建和使用:

1. spring 项目的创建

创建一个Spring(Core):

a.创建一个maven项目

此时就已经初始化好了!!!

b.添加Spring依赖 

添加依赖最终要的一部就是设置国内源(配置国内源的目的是让maven不再从国际上的服务器进行配置提高成功率和速度)

maven helper(控制依赖的插件)

在idea中有两个配置文件的设置:

 然后在相关目录中添加setting.xml文件

三个√需要进行更改. 而且注意路径不要有中文

然后根据上面的路径进入settings.xml

 在这个setting 文件中,有一段镜像的国内源的url:

有了这个进行依赖将会从阿里的服务器进行获取,而不是国外的maven仓库了.

然后重新下载jar包:

为了保证所有jar包走的都是国内源,我们要清空本地所有的jar包,然后再重新下载.

jar包保存在这里 .

另外,还有可能有其他的问题:

比如说运营商问题之类的,这个问题可以换一个网络如:联通移动之类的.

然后添加spring框架的依赖:

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.20</version></dependency>

c.创建启动类 

2.将 bean 存储 Spring ( 容器 )

首先是创建一个文件:

然后将这段配置文件复制到上面:

<?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:content="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 https://www.springframework.org/schema/context/spring-context.xsd">
</beans>

 在这个文件中就可以自己写bean对象.

如果目录是这样子的结构的:

 我们的bean标签中就需要这样进行规定:

3.从 Spring 中获取 bean[ DI ]

首先是得到Spring (上下文) 对象.

第一种方法:

使用ApplicationContext类进行对象的创建(注意要填写正确的配置文件)

然后从spring容器中获取我们的bean:

注意此时的getbean括号内存储的是这个id,怎么存所以怎么取 

 然后就是使用bean

 注意:在代码编写的时候需要注意路径与id:

这个代码编写的目的在于:

没new对象却实现了类里的方法的调用.

第二种方法:

跟第一种方法类似,但是这种方法其实就是ApplicationContext类的一个"替代",类似古代的"钦差"之类的,"见钦差如见皇帝"这个意思.

这两种方法的区别:

首先准备两个构造方法和普通方法

 分别运行两种方法:

 当使用的是ApplicationContext的时候,运行到

        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");

的时候会将所有的bean对象初始化.

而BeanFactory是当你执行到

Student student=(Student) beanFactory.getBean("student");

时,才会初始化指定的bean对象初始化.

所以说,ApplicationContext比较占用内存,但是效率高调用快;但是BeanFactory比较省内存,但是调用慢,效率低.

从继承和功能的角度:ApplicationContext是BeanFactory的子类,所以它除了有BeanFactory的全部功能,还有一些它独特的功能.(对国际化支持,资源访问支持,时间传播)

获取Bean的三种方式:

1.通过名称进行获取

2.通过类型进行获取 

但是这种获取的方式只能让这一个类型在spring 存一次,如果在bean中存储同一个类型进行多次获取,就会报错. 

3.类型和名称一块获取

其实每一个人工创建的bean,spring都会单独创建一块区域来进行存储,所以算输出的结果相同,但不是同一个bean也是不一样的.

 比如说此时student和stu所打印的内容都是一样的.

 此时打印的结果是:

三、Spring中的简单的读取对象(使用类注解)

注解:可以开启提交和回滚事务(一种是在编译器的环境下直接加代码,一种是通过拦截然后开启事务的方式实现)

之前其实是:

在beans中添加bean,这种方式其实比new更复杂.

此时如果有一种方法,使用注解直接充当sping 的入口. 

五大类注解:

1. @Controller

控制器:验证用户请求的数据正确性.(相当于安保系统)

2. @Service

服务:编排和调度具体执行方法的.(客服中心)

3. @Repository

持久层:和数据库进行交互.(执行者)

另外,我们平时所说的DAO层,DAO(Data Access Object)数据访问层,而@Repository就是其中的一种实现

4. @Component

组件:(工具类)

5.  @Configuration

配置类: (项目中的一些配置)

使用五大注释:

首先创建一个spring项目:

引入依赖等和上面一致.

另外,在使用注释之前还需要做一些准备:

在resources目录底下设置配置文件. 

<?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:content="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 https://www.springframework.org/schema/context/spring-context.xsd"><content:component-scan base-package="com.bit.service"></content:component-scan>
</beans>

 注意此处的红框中是指定的文件夹,就是让spring指定的去扫描文件,这样可以让程序运行的效率更上一层楼.

设置一个类,调用里面的方法,此时这个注释就是充当了之前bean标签的作用.

之后编写主类,跟之前的一致:

只不过这里的id变为了类名的小驼峰形式.

所以要记住是使用:小驼峰进行访问 

Springboot使用方式:

首先这里修改了端口号

写了一个接口返回hello spring,并设定了url

调用了这个url,成功访问:

四、什么是MVC:

就像面试一样,我去面试的话HR来接待,但相应的面试需要公司负责人进行接触,公司具体项目负责人去找人充当面试官

HR -> view

公司具体项目负责人 -> controller

面试官 -> model

也就是一个接待用户,一个找具体谁来干活,一个干活

五、什么是springMVC:

spring结合自身的特点也创造了一款独特的MVC,符合自身特点的:

这个也就是,面试人直接去找部门负责人,然后部门负责人去找相对应面试官安排面试,然后面试通过后部门负责人告诉HR面试人面试通过了,让HR给这个人发offer,HR再和面试人交接

六、SpringBoot常用方法:

建立连接

@RequestMapping-类路径

@RestController-spring标识,告诉spring这个是个需要考虑的类

@RequestMapping制造url,我们要想访问对应页面需要再html页面中填入对应url即可成功进行交互

另外@RequestMapping可以设定接收信息的方法是get还是post

也有@GetMapping只能接受get方法:

也有@PostMapping

另外还有前后端传参:

也可以传两个参数

servlet和springboot的区别:

前后端传递多个参数:

现在企业中通常传递多个对象的方式是这样的:

首先封装对象:

package com.example.demo;/*** Created with IntelliJ IDEA.* Description:* User: 86139* Date: 2025-07-21* Time: 21:33*/
public class User {private String name;private Integer age;private Integer gender;public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public Integer getGender() {return gender;}public void setGender(Integer gender) {this.gender = gender;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +", gender=" + gender +'}';}
}

然后直接打印对象: 

    @RequestMapping("/p1")public String test(User user){return "user:"+user}

如果前端想要传的'name'与后端传的这个'username'不一样,也就是后端不想要用前端传输的这个name进行存储:

    @RequestMapping("/p2")public String test2(@RequestParam("userName") String name){return "name:"+name;}

但如果设定了这个参数绑定@RequestParam后再传之前的变量名,则显示报错400

但是这样太绝对了,如果收到不一致的值直接报错,会导致程序结束,我们想要收到不一致的值返回false怎么办呢?

如果不写这个required的话就默认是value.

    @RequestMapping("/p2")public String test2(@RequestParam(value="userName",required = false) String name){return "name:"+name;}

这样就可以了

通过数组传参:

    @RequestMapping("/p3")public String test3(String[] arr){return "name:"+ Arrays.toString(arr);}

也可以这样:

当前端没有指定数据进行传参时,我们后端可以手动参数绑定将其设置为数组:

    @RequestMapping("/p4")public String test4(@RequestParam List<String> list){return "name:"+ list;}

idea中对象转JSON格式:

public class test {public static void main(String[] args) throws JsonProcessingException {ObjectMapper objectMapper=new ObjectMapper();User user=new User();user.setName("zhangsan");user.setAge(20);user.setGender(1);String s=objectMapper.writeValueAsString(user);System.out.println(s);}}

idea中Json转对象:

public class test {public static void main(String[] args) throws JsonProcessingException {ObjectMapper objectMapper=new ObjectMapper();User user=new User();user.setName("zhangsan");user.setAge(20);user.setGender(1);String s=objectMapper.writeValueAsString(user);
//        System.out.println(s);User user1=objectMapper.readValue(s,User.class);System.out.println(user1);}}

前端传递JSON和传递对象的区别:

而我们在场景中经常遇到的是接收JSON数据,如何更加简单的接收Json格式数据将其转化为对象呢?

转化Json格式为对象:

    @RequestMapping("/p5")public String tset5(@RequestBody User user){return "user:"+user;}

获取url中id:

    @RequestMapping("/p6/{id}")public String test6(@PathVariable("id")String id){return "id:"+id;}

也可以获取多个参数:

    @RequestMapping("/p6/{id}/{name}")public String test6(@PathVariable("id")String id,@PathVariable("name")String name){return "id,name:"+id+name;}

上传文件及其重命名:

七、cookie:

八、session:

九、Cookie和Session 的区别:

如何获取cookie值:

    @RequestMapping("/helloCookie")public String Cookie(HttpServletRequest httpServletRequest){Cookie[] cookies=httpServletRequest.getCookies();for(Cookie cookie:cookies){if(cookie != null) {System.out.println(cookie.getName()+":"+cookie.getValue());}else{break;}}return "cookie获取成功!!!";}

我们可以看到在服务器控制台是可以正常打印cookie值的:

另外还有一种获取cookie值的方法:

直接将cookie名写入代码:

    @RequestMapping("/helloCookie2")public String Cookie2(@CookieValue("test")String test){return "test:"+test;}

set以及get session:

    @RequestMapping("/setSeesion")public String Session2(HttpServletRequest httpServletRequest){HttpSession session=httpServletRequest.getSession();session.setAttribute("userName","zhangsan");session.setAttribute("age",15);return "设置session成功";}@RequestMapping("/getSeesion")public String Session1(HttpServletRequest httpServletRequest){HttpSession session=httpServletRequest.getSession();String userName=(String)session.getAttribute("userName");System.out.println(session.getAttribute("age"));return "从cookie中获取值,session:"+userName;}

首先模拟客户端建立cookie输入userName与age,然后生成了session

然后再重session中重新获取组成session的cookie:

这样获取session也行:

优化一下:

获取session有三种方式,可以根据应用场景进行选择.

User-Agent:

User-Agent是跟着一个session走的,后台需要知道这个人的喜好以及很多个人信息,就存储在User-Agent中,而想要获取User-Agent也有两种方法:

    @RequestMapping("/User-Agent1")public String agent1(HttpServletRequest httpServletRequest) {String user = httpServletRequest.getHeader("User-Agent");return "User-Agent:" + user;}@RequestMapping("/User-Agent2")public String agent2(@RequestHeader("User-Agent")String user) {return "User-Agent:"+user;}

上面应用的几乎都是spring 中request的功能,接下来我们要研究的就是response的功能了:

十、response

如果想要直接通过后端代码进行前端的页面跳转应该怎么办呢?

@Controller
@RequestMapping("/response")
public class send {@RequestMapping("/hello")public String send(){return "/hello.html";}
}

此处用的标签是@controller而不是@Restcontroller,它俩的关系是@Restcontrollers是在@controller的基础上完善的:

所以说返回数据 -> @ResponseBody

返回页面 -> @Controller

        @ResponseBody@RequestMapping("/this is data")public String data(){return "data.html";}

返回Json:

    @ResponseBody@RequestMapping("/returnJson")public User returnJson(){User user=new User();user.setName("zhangsan");user.setAge(20);user.setGender(1);return user;}

设置状态码:

    @ResponseBody@RequestMapping("/returnJson")public User returnJson(HttpServletResponse httpServletResponse){User user=new User();user.setName("zhangsan");user.setAge(20);user.setGender(1);httpServletResponse.setStatus(500);return user;}

虽然程序不会结束,但是会返回一个500的状态码

设置Header:

这个主要就是能改变header中的传输的信息的类型:

    @ResponseBody@RequestMapping(value="/setHeader",produces = "application/json")public String setHeader(){return "{\"name\":\"zhangsan\",\"age\":20,\"gender\":1}";}

也可以这样设置:

    @ResponseBody@RequestMapping("setHeader2")public void setHeader2(HttpServletResponse response){response.setHeader("test","myTest");}

十一、MVC与三层架构:

三层架构是现在开发中常用的设计模式:表现层、业务逻辑层、数据访问层

MVC强调数据和视图分离,将数据展示和数据处理分开,通过控制器对二者进行组合

三层架构强调不同维度数据处理的高内聚和低耦合,将交互页面,业务处理和数据库操作分开

总结: