目录
Maven
Maven是apache旗下的一个开源项目，是一款用于管理和构建java项目的工具。
Maven的作用
依赖管理
方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题
统一项目结构
提供标准、统一的项目结构
项目构建
标准跨平台（Linux、Windows、MacOS）的自动化项目构建方式
介绍与安装配置
创建Maven项目
Maven坐标
IDEA 导入 Maven 项目
依赖配置
依赖传递
依赖范围
生命周期
SpringBoot
spring boot web快速入门
HTTP协议
HTTP协议概述
HTTP请求协议
HTTP-请求数据格式
HTTP响应协议
请求响应介绍-HTTP响应格式
HTTP协议解析
Web服务器—Tomcat
SpringBootWeb-入门程序解析
请求响应
请求
postman
简单参数
简单参数：参数名与形参变量名相同，定义形参即可接收参数。
@RestController
public class RequestController {
// http://localhost:8080/simpleParam?name=Tom&age=10
// 第1个请求参数： name=Tom 参数名:name，参数值:Tom
// 第2个请求参数： age=10 参数名:age , 参数值:10
//springboot方式
@RequestMapping("/simpleParam")
public String simpleParam(String name , Integer age ){//形参名和请求参数名保持一致
System.out.println(name+" : "+age);
return "OK";
}
}
结论：不论是GET请求还是POST请求，对于简单参数来讲，只要保证==请求参数名和Controller方法中的形参名保持一致==，就可以获取到请求参数中的数据值。
参数名不一致
实体参数
简单实体对象
复杂实体对象
复杂实体对象的封装，需要遵守如下规则：
-
请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套实体类属性参数。
User实体类 ：
public class User {
private String name;
private Integer age;
private Address address; //地址对象
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 Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", address=" + address +
'}';
}
}
数组集合参数
数组集合参数的使用场景：在HTML的表单中，有一个表单项是支持多选的(复选框)，可以提交选择的多个值。
数组
集合
集合参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam 绑定参数关系
默认情况下，请求中参数名相同的多个值，是封装到数组。如果要封装到集合，要使用@RequestParam绑定参数关系
日期参数
JSON参数
路径参数
响应
前面我们学习过HTTL协议的交互方式：请求响应模式（有请求就有响应）
那么Controller程序呢，除了接收请求外，还可以进行响应。
@ResponseBody
在我们前面所编写的controller方法中，都已经设置了响应数据。
controller方法中的return的结果，怎么就可以响应给浏览器呢？
答案：使用@ResponseBody注解
@ResponseBody注解：
-
类型：方法注解、类注解
-
位置：书写在Controller方法上或类上
-
作用：将方法返回值直接响应给浏览器
-
如果返回值类型是实体对象/集合，将会转换为JSON格式后在响应给浏览器
-
但是在我们所书写的Controller中，只在类上添加了@RestController注解、方法添加了@RequestMapping注解，并没有使用@ResponseBody注解，怎么给浏览器响应呢？
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
System.out.println("Hello World ~");
return "Hello World ~";
}
}原因：在类上添加的@RestController注解，是一个组合注解。
-
@RestController = @Controller + @ResponseBody
@RestController源码：
@Target({ElementType.TYPE}) //元注解（修饰注解的注解）
@Retention(RetentionPolicy.RUNTIME) //元注解
@Documented //元注解
@Controller
@ResponseBody
public @interface RestController {
@AliasFor(
annotation = Controller.class
)
String value() default "";
}结论：在类上添加@RestController就相当于添加了@ResponseBody注解。
-
类上有@RestController注解或@ResponseBody注解时：表示当前类下所有的方法返回值做为响应数据
-
方法的返回值，如果是一个POJO对象或集合时，会先转换为JSON格式，在响应给浏览器
-
下面我们来测试下响应数据：
@RestController
public class ResponseController {
//响应字符串
@RequestMapping("/hello")
public String hello(){
System.out.println("Hello World ~");
return "Hello World ~";
}
//响应实体对象
@RequestMapping("/getAddr")
public Address getAddr(){
Address addr = new Address();//创建实体类对象
addr.setProvince("广东");
addr.setCity("深圳");
return addr;
}
//响应集合数据
@RequestMapping("/listAddr")
public List<Address> listAddr(){
List<Address> list = new ArrayList<>();//集合对象
Address addr = new Address();
addr.setProvince("广东");
addr.setCity("深圳");
Address addr2 = new Address();
addr2.setProvince("陕西");
addr2.setCity("西安");
list.add(addr);
list.add(addr2);
return list;
}
}在服务端响应了一个对象或者集合，那私前端获取到的数据是什么样子的呢？我们使用postman发送请求来测试下。测试效果如下：
统一响应结果
统一的返回结果使用类来描述，在这个结果中包含：
-
响应状态码：当前请求是成功，还是失败
-
状态码信息：给页面的提示信息
-
返回的数据：给前端响应的数据（字符串、对象、集合）
定义在一个实体类Result来包含以上信息。代码如下：
public class Result {
private Integer code;//响应码，1 代表成功; 0 代表失败
private String msg; //响应码 描述字符串
private Object data; //返回的数据
public Result() { }
public Result(Integer code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
//增删改 成功响应(不需要给前端返回数据)
public static Result success(){
return new Result(1,"success",null);
}
//查询 成功响应(把查询结果做为返回数据响应给前端)
public static Result success(Object data){
return new Result(1,"success",data);
}
//失败响应
public static Result error(String msg){
return new Result(0,msg,null);
}
}改造Controller：
@RestController
public class ResponseController {
//响应统一格式的结果
@RequestMapping("/hello")
public Result hello(){
System.out.println("Hello World ~");
//return new Result(1,"success","Hello World ~");
return Result.success("Hello World ~");
}
//响应统一格式的结果
@RequestMapping("/getAddr")
public Result getAddr(){
Address addr = new Address();
addr.setProvince("广东");
addr.setCity("深圳");
return Result.success(addr);
}
//响应统一格式的结果
@RequestMapping("/listAddr")
public Result listAddr(){
List<Address> list = new ArrayList<>();
Address addr = new Address();
addr.setProvince("广东");
addr.setCity("深圳");
Address addr2 = new Address();
addr2.setProvince("陕西");
addr2.setCity("西安");
list.add(addr);
list.add(addr2);
return Result.success(list);
}
}使用Postman测试：
案例
代码实现
Contriller代码：
@RestController
public class EmpController {
@RequestMapping("/listEmp")
public Result list(){
//1. 加载并解析emp.xml
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
//System.out.println(file);
List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
//2. 对数据进行转换处理 - gender, job
empList.stream().forEach(emp -> {
//处理 gender 1: 男, 2: 女
String gender = emp.getGender();
if("1".equals(gender)){
emp.setGender("男");
}else if("2".equals(gender)){
emp.setGender("女");
}
//处理job - 1: 讲师, 2: 班主任 , 3: 就业指导
String job = emp.getJob();
if("1".equals(job)){
emp.setJob("讲师");
}else if("2".equals(job)){
emp.setJob("班主任");
}else if("3".equals(job)){
emp.setJob("就业指导");
}
});
//3. 响应数据
return Result.success(empList);
}
}统一返回结果实体类：
public class Result {
private Integer code ;//1 成功 , 0 失败
private String msg; //提示信息
private Object data; //数据 date
public Result() {
}
public Result(Integer code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static Result success(Object data){
return new Result(1, "success", data);
}
public static Result success(){
return new Result(1, "success", null);
}
public static Result error(String msg){
return new Result(0, msg, null);
}
}测试
问题分析
上述案例的功能，我们虽然已经实现，但是呢，我们会发现案例中：解析XML数据，获取数据的代码，处理数据的逻辑的代码，给页面响应的代码全部都堆积在一起了，全部都写在controller方法中了。
当前程序的这个业务逻辑还是比较简单的，如果业务逻辑再稍微复杂一点，我们会看到Controller方法的代码量就很大了。
-
当我们要修改操作数据部分的代码，需要改动Controller
-
当我们要完善逻辑处理部分的代码，需要改动Controller
-
当我们需要修改数据响应的代码，还是需要改动Controller
这样呢，就会造成我们整个工程代码的复用性比较差，而且代码难以维护。 那如何解决这个问题呢？其实在现在的开发中，有非常成熟的解决思路，那就是分层开发。
分层解耦
三层架构
介绍
在我们进行程序设计以及程序开发时，尽可能让每一个接口、类、方法的职责更单一些（单一职责原则）。
单一职责原则：一个类或一个方法，就只做一件事情，只管一块功能。
这样就可以让类、接口、方法的复杂度更低，可读性更强，扩展性更好，也更利用后期的维护。
我们之前开发的程序呢，并不满足单一职责原则。下面我们来分析下之前的程序：
那其实我们上述案例的处理逻辑呢，从组成上看可以分为三个部分：
-
数据访问：负责业务数据的维护操作，包括增、删、改、查等操作。
-
逻辑处理：负责业务逻辑处理的代码。
-
请求处理、响应数据：负责，接收页面的请求，给页面响应数据。
按照上述的三个组成部分，在我们项目开发中呢，可以将代码分为三层：
代码拆分
@RestController
public class EmpController {
//业务层对象
private EmpService empService = new EmpServiceA();
@RequestMapping("/listEmp")
public Result list(){
//1. 调用service层, 获取数据
List<Emp> empList = empService.listEmp();
//3. 响应数据
return Result.success(empList);
}
}
业务实现类
分层解耦
刚才我们学习过程序分层思想了，接下来呢，我们来学习下程序的解耦思想。
解耦：解除耦合。
耦合问题
首先需要了解软件开发涉及到的两个概念：内聚和耦合。
-
内聚：软件中各个功能模块内部的功能联系。
-
耦合：衡量软件中各个层/模块之间的依赖、关联的程度。
软件设计原则：高内聚低耦合。
高内聚指的是：一个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段)之间的联系程度越高，则内聚性越高，即 "高内聚"。
低耦合指的是：软件中各个层、模块之间的依赖关联程序越低越好。
程序中高内聚的体现：
-
EmpServiceA类中只编写了和员工相关的逻辑处理代码
解耦思路
我们想要实现上述解耦操作，就涉及到Spring中的两个核心概念：
-
控制反转： Inversion Of Control，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。
对象的创建权由程序员主动创建转移到容器(由容器创建、管理对象)。这个容器称为：IOC容器或Spring容器
-
依赖注入： Dependency Injection，简称DI。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。
程序运行时需要某个资源，此时容器就为其提供这个资源。
例：EmpController程序运行时需要EmpService对象，Spring容器就为其提供并注入EmpService对象
IOC容器中创建、管理的对象，称之为：bean对象
IOC&DI
IOC&DI入门
任务：完成Controller层、Service层、Dao层的代码解耦
-
思路：
-
删除Controller层、Service层中new对象的代码
-
Service层及Dao层的实现类，交给IOC容器管理
-
为Controller及Service注入运行时依赖的对象
-
Controller程序中注入依赖的Service层对象
-
Service程序中注入依赖的Dao层对象
-
-
第1步：删除Controller层、Service层中new对象的代码
第2步：Service层及Dao层的实现类，交给IOC容器管理
-
使用Spring提供的注解：@Component ，就可以实现类交给IOC容器管理
第3步：为Controller及Service注入运行时依赖的对象
-
使用Spring提供的注解：@Autowired ，就可以实现程序运行时IOC容器自动注入需要的依赖对象
完整的三层代码：
-
Controller层：
@RestController
public class EmpController {
@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量
private EmpService empService ;
@RequestMapping("/listEmp")
public Result list(){
//1. 调用service, 获取数据
List<Emp> empList = empService.listEmp();
//3. 响应数据
return Result.success(empList);
}
}Service层：
@Component //将当前对象交给IOC容器管理,成为IOC容器的bean
public class EmpServiceA implements EmpService {
@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量
private EmpDao empDao ;
@Override
public List<Emp> listEmp() {
//1. 调用dao, 获取数据
List<Emp> empList = empDao.listEmp();
//2. 对数据进行转换处理 - gender, job
empList.stream().forEach(emp -> {
//处理 gender 1: 男, 2: 女
String gender = emp.getGender();
if("1".equals(gender)){
emp.setGender("男");
}else if("2".equals(gender)){
emp.setGender("女");
}
//处理job - 1: 讲师, 2: 班主任 , 3: 就业指导
String job = emp.getJob();
if("1".equals(job)){
emp.setJob("讲师");
}else if("2".equals(job)){
emp.setJob("班主任");
}else if("3".equals(job)){
emp.setJob("就业指导");
}
});
return empList;
}
}Dao层：
@Component //将当前对象交给IOC容器管理,成为IOC容器的bean
public class EmpDaoA implements EmpDao {
@Override
public List<Emp> listEmp() {
//1. 加载并解析emp.xml
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
System.out.println(file);
List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
return empList;
}
}运行测试：
-
启动SpringBoot引导类，打开浏览器，输入：http://localhost:8080/emp.html
IOC详解
通过IOC和DI的入门程序呢，我们已经基本了解了IOC和DI的基础操作。接下来呢，我们学习下IOC控制反转和DI依赖注入的细节。
bean的声明
前面我们提到IOC控制反转，就是将对象的控制权交给Spring的IOC容器，由IOC容器创建及管理对象。IOC容器创建的对象称为bean对象。
在之前的入门案例中，要把某个对象交给IOC容器管理，需要在类上添加一个注解：@Component
而Spring框架为了更好的标识web应用程序开发当中，bean对象到底归属于哪一层，又提供了@Component的衍生注解：
-
@Controller （标注在控制层类上）
-
@Service （标注在业务层类上）
-
@Repository （标注在数据访问层类上）
修改入门案例代码：
-
Controller层：
@RestController //@RestController = @Controller + @ResponseBody
public class EmpController {
@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量
private EmpService empService ;
@RequestMapping("/listEmp")
public Result list(){
//1. 调用service, 获取数据
List<Emp> empList = empService.listEmp();
//3. 响应数据
return Result.success(empList);
}
}Service层：
@Service
public class EmpServiceA implements EmpService {
@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量
private EmpDao empDao ;
@Override
public List<Emp> listEmp() {
//1. 调用dao, 获取数据
List<Emp> empList = empDao.listEmp();
//2. 对数据进行转换处理 - gender, job
empList.stream().forEach(emp -> {
//处理 gender 1: 男, 2: 女
String gender = emp.getGender();
if("1".equals(gender)){
emp.setGender("男");
}else if("2".equals(gender)){
emp.setGender("女");
}
//处理job - 1: 讲师, 2: 班主任 , 3: 就业指导
String job = emp.getJob();
if("1".equals(job)){
emp.setJob("讲师");
}else if("2".equals(job)){
emp.setJob("班主任");
}else if("3".equals(job)){
emp.setJob("就业指导");
}
});
return empList;
}
}Dao层：
@Repository
public class EmpDaoA implements EmpDao {
@Override
public List<Emp> listEmp() {
//1. 加载并解析emp.xml
String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
System.out.println(file);
List<Emp> empList = XmlParserUtils.parse(file, Emp.class);
return empList;
}
}
组件扫描
DI详解
扫一扫
1185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
