目录

一、请求响应

1、请求

（1）简单参数

① GET请求

 ② POST请求

③ 假如形参与请求参数不一致

（2）实体参数

① 简单实体对象

② 复杂实体对象

（3）数组参数

（4）集合参数

（5）日期参数

（6） json参数

 （7）路径参数

 2、统一响应

（1）设置一个响应类Result

（2）设置响应代码

3、案例

（1） 引入相关资料

（2）编写程序处理请求，响应数据

 （3）测试

二、分层解耦

1、三层架构

（1）编写Dao层代码

① Dao层接口 

② Dao层接口实现类 

（2）编写service层代码

① Service层接口  

② Service层接口实现类 

（3）编写controller层代码

2、分层解耦

（1）概念

 （2）控制反转与依赖注入

3、IOC和DI

（1）Controller层

（2）Service层

（3）Dao层

（4）更改同层Bean对象

（5）如何看查Bean对象？

4、IOC详解

5、DI详解 

（1）@Primary

（2）@Autowired+@Qualifier("bean的名称")

（3）@Resource(name="bean的名称")

---

一、请求响应

1、请求

（1）简单参数

简单参数：你在方法里写的形参与请求参数名称匹配，则返回方法内数据

package com.roye;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController  //请求处理类
public class Springbootwebrequest {
    //基于springboot方式
    @RequestMapping("/example01")  //浏览器将来请求/example01这个地址，会调用该方法
    public static String example01(String name,Integer age)
    {
        System.out.println("name:"+name+" age:"+age);
        return "OK";
    }
}

① GET请求

运行后用postman新建一个get请求，输入网页地址及参数即可获取内容

 

 ② POST请求

post内容在请求体中

③ 假如形参与请求参数不一致

可以用@RequestParam完成映射

@RestController  //请求处理类
public class Springbootwebrequest {
    //基于springboot方式
    @RequestMapping("/example01")  //浏览器将来请求/example01这个地址，会调用该方法
    public static String example01(@RequestParam(name="name") String username, Integer age)
    {
        System.out.println("name:"+username+" age:"+age);
        return "OK";
    }
}

其中required默认值为true，意思为请求参数必须传递

@RestController  //请求处理类
public class Springbootwebrequest {
    //基于springboot方式
    @RequestMapping("/example01")  //浏览器将来请求/example01这个地址，会调用该方法
    public static String example01(@RequestParam(name="name",required = false) String username, Integer age)
    {
        System.out.println("name:"+username+" age:"+age);
        return "OK";
    }
}

（2）实体参数

规则：请求参数名与形参名相同

① 简单实体对象

先定义一个类

public class User {
    private String name;
    private String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

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

方法中参数设为类

//实体参数-简单实体
    @RequestMapping("/example02")
    public static String example02(User x) {
        System.out.println(x);
        return "OK";
    }

② 复杂实体对象

//实体参数-复杂实体
    @RequestMapping("/example03")
    public static String example03(User x) {
        System.out.println(x);
        return "OK";

就是类嵌套着类！ 

public class User {
    private String name;
    private String age;
    private Address address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String 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 + '\'' +
                '}';
    }
}

public class Address {
    private String province;
    private String city;

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

（3）数组参数

    //数组参数
    @RequestMapping("/example04")
    public static String example04(String[] hobby) {
        System.out.println(Arrays.toString(hobby));
        return "OK";
    }

 

（4）集合参数

    //集合参数
    @RequestMapping("/example05")
    public static String example05(@RequestParam List<String> hobby) {
        System.out.println(hobby);
        return "OK";
    }

（5）日期参数

    //日期时间参数
    @RequestMapping("/example06")
    public static String example06(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime time) {
        System.out.println(time);
        return "OK";
    }

 

（6） json参数

    //json参数
    @RequestMapping("/example07")
    public static String example07(@RequestBody User x) {
        System.out.println(x);
        return "OK";
    }

 

 （7）路径参数

    //路径参数
    @RequestMapping("/path/{id}/{name}")
    public static String example08(@PathVariable Integer id,@PathVariable String name) {
        System.out.println(id+":"+name);
        return "OK";
    }

 

 2、统一响应

@RestControlled 包含 @ResponseBody

（1）设置一个响应类Result

package com.roye.day5;

/**
 * 统一响应结果封装类
 */
public class Result {
    private Integer code ;//1 成功 , 0 失败
    private String msg; //提示信息
    private Object data; //数据 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(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);
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

（2）设置响应代码

    @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);
    }
}

 

3、案例

（1） 引入相关资料

 

 Springboot项目的静态资源（HTML、css、js等前端）默认存放目录 static

（2）编写程序处理请求，响应数据

package com.roye;

import com.roye.day5.Emp;
import com.roye.day5.Result;
import com.roye.tools.XmlParserUtils;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

import static org.springframework.util.ResourceUtils.getFile;

@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、对数据进行转换处理
        emplist.stream().forEach(x -> {
            //处理gender 1：男 2：女
            String gender=x.getGender();
            if("1".equals(gender)) x.setGender("男");
            else if("2".equals(gender)) x.setGender("女");

            //处理job 1：讲师 2：班主任 3：就业指导
            String job=x.getJob();
            if("1".equals(job)) x.setJob("讲师");
            else if("2".equals(job)) x.setJob("班主任");
            else if("3".equals(job)) x.setJob("就业指导");
        });

        //3、响应数据
        return Result.success(emplist);
    }
}

 （3）测试

 

二、分层解耦

1、三层架构

对于上面那个案例，我们把代码全部写一块，复用性差，难以维护

• controller：控制层，接收前端发送的请求，对请求进行处理，并响应数据
• service：业务逻辑层，处理具体业务逻辑
• dao：数据访问层，包括数据的增删改查

（1）编写Dao层代码

① Dao层接口 

//接口
package com.roye.dao;

import com.roye.day5.Emp;

import java.util.List;

public interface EmpDao {
    //获取员工列表数据
    public List<Emp> listEmp();
}

② Dao层接口实现类 

//接口实现类
package com.roye.dao.impl;

import com.roye.dao.EmpDao;
import com.roye.day5.Emp;
import com.roye.tools.XmlParserUtils;

import java.util.List;

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;
    }
}

（2）编写service层代码

① Service层接口  

package com.roye.service;

import com.roye.day5.Emp;

import java.util.List;

public interface EmpService {
    //获取员工列表
    public List<Emp> listEmp();
}

② Service层接口实现类 

package com.roye.service.impl;

import com.roye.dao.EmpDao;
import com.roye.dao.impl.EmpDaoA;
import com.roye.day5.Emp;

import java.util.List;

public class EmpService implements com.roye.service.EmpService {
    private EmpDao empDao=new EmpDaoA();  //设接口实现类
    @Override
    public List<Emp> listEmp() {
        //1、调用Dao，获取数据
        List<Emp> empList=empDao.listEmp();

        //2、对数据进行转换处理
        empList.stream().forEach(x -> {
            //处理gender 1：男 2：女
            String gender=x.getGender();
            if("1".equals(gender)) x.setGender("男");
            else if("2".equals(gender)) x.setGender("女");

            //处理job 1：讲师 2：班主任 3：就业指导
            String job=x.getJob();
            if("1".equals(job)) x.setJob("讲师");
            else if("2".equals(job)) x.setJob("班主任");
            else if("3".equals(job)) x.setJob("就业指导");
        });
        return empList;
    }
}

（3）编写controller层代码

package com.roye.controller;

import com.roye.day5.Emp;
import com.roye.day5.Result;
import com.roye.service.EmpService;
import com.roye.tools.XmlParserUtils;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

import static org.springframework.util.ResourceUtils.getFile;

@RestController
public class EmpController {
    private EmpService empService=new com.roye.service.impl.EmpService();
    
    @RequestMapping("/listEmp")
    public Result list(){
        //1、调用Service，获取数据
        List<Emp> empList=empService.listEmp();
        
        //2、响应数据
        return Result.success(empList);
    }
}

2、分层解耦

（1）概念

• 内聚：每个模块间功能的联系
• 耦合：衡量软件中各模块间的依赖关联程度
• 软件设计原则：高内聚低耦合

 （2）控制反转与依赖注入

• 控制反转 IOC：对象创建控制权由程序内部移向外部（容器）
• 依赖注入 DI：容器为程序运行所依赖的资源
• Bean对象：IOC容器中创建、管理的对象

3、IOC和DI

注解在各层的应用

注解	作用	Controller层	Service层	Dao层
@Component	声明bean对象，将当前类交给IOC容器管理		✓	✓
@Autowired	运行时，IOC容器会提供该类型的Bean对象，并赋值给该变量	✓	✓

• Controller层需要调用Service层（进行逻辑处理）【@Autowired】，因此将Service层放入IOC容器【@Component】
• Service层需要调用Dao层（进行获取数据）【@Autowired】，因此将Dao层放入IOC容器【@Component】

（1）Controller层

@RestController
public class EmpController {
    @Autowired  //运行时，IOC容器会提供该类型的Bean对象，并赋值给该变量
    private EmpService empService;

    @RequestMapping("/listEmp")
    public Result list(){
        //1、调用Service，获取数据
        List<Emp> empList=empService.listEmp();

        //2、响应数据
        return Result.success(empList);
    }
}

（2）Service层

@Component  //将当前类交给IOC容器管理，称为IOC容器中的Bean
public class EmpService implements com.roye.service.EmpService {
    @Autowired  //运行时，IOC容器会提供该类型的Bean对象，并赋值给该变量
    private EmpDao empDao;

    @Override
    public List<Emp> listEmp() {
        //1、调用Dao，获取数据
        List<Emp> empList=empDao.listEmp();

        //2、对数据进行转换处理
        empList.stream().forEach(x -> {
            //处理gender 1：男 2：女
            String gender=x.getGender();
            if("1".equals(gender)) x.setGender("男");
            else if("2".equals(gender)) x.setGender("女");

            //处理job 1：讲师 2：班主任 3：就业指导
            String job=x.getJob();
            if("1".equals(job)) x.setJob("讲师");
            else if("2".equals(job)) x.setJob("班主任");
            else if("3".equals(job)) x.setJob("就业指导");
        });
        return empList;
    }
}

（3）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;
    }
}

（4）更改同层Bean对象

假设Service层出现两个类

 要将EmpServiceB应用，则把EmpService中的@Component注释掉

（5）如何看查Bean对象？

4、IOC详解

•  前面声明bean四大注解，想要生效，需要被组件扫描注解@ComponentScan扫描
• @ComponentScan已经包含在启动类声明注解@SpringBootApplication中，默认扫描范围为启动类所在包及子包

 

5、DI详解 

@Autowired注解，默认是按类型注解，如果存在多个相同类型的bean，将会报错！

（1）@Primary

（2）@Autowired+@Qualifier("bean的名称")

（3）@Resource(name="bean的名称")