【javaweb】学习日记Day5 - 请求响应 分层解耦 IOC DI 三层架构

最新推荐文章于 2024-07-18 21:11:52 发布
最新推荐文章于 2024-07-18 21:11:52 发布
阅读量645 收藏
点赞数
分类专栏： Javaweb 文章标签： 学习 IOC 分层解耦 DI 请求响应
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61639349/article/details/132444993
版权

目录

一、请求响应

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的名称")

 

 

 

Roye_ack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaWeb三层架构和五层架构介绍
01-07
JavaWeb 三层架构和五层架构介绍 JavaWeb 开发中，程序的划分是基于“高内聚低耦合”的思想，主要体现在三层架构和五层架构中。下面将详细介绍这两种架构的结构、特点和优缺点。 三层架构 三层架构是从整个业务...
JavaWeb三层架构案例 信息管理系统 ThreeTireSample
05-15
JavaWeb三层架构是一种常见的软件设计模式，用于构建可维护、可扩展且结构清晰的Web应用程序。在这个名为"ThreeTireSample"的案例中，我们将会深入探讨如何运用三层架构来开发一个信息管理系统。 首先，我们要理解...
优雅实现request请求IOC
尹忠政的博客
09-17 563
前言上篇我们谈到了如何通过过滤器去分发请求，实现了请求servlet的特定方法的问题，那么携带的参数如何转化为我们想要的javaBean呢？今天就探讨一下该问题该如何解决。
【Spring】（2）浅谈IOC
weixin_44823875的博客
03-27 272
【Spring】（2）浅谈IOC（1）IOC是啥（1.1）IOC概念（1.2）IOC的内部结构（1.3）IOC、Bean、注入之间的关系（2）为什么使用IOC（3）IOC的4种配置方式（3.1）基于Xml（3.2）基于注解（3.2.1）定义Bean（对象）（3.2.2）扫描Bean（3.2.3）自动装配Bean（3.3）Bean的作用范围（3.4）生命过程方法（4）对IOC的深入理解Bean的生命...
SpringMvc框架(IoC容器上下文和映射请求上下文)
qq_41649001的博客
07-03 812
目录,更新ing,学习Java的点滴记录   目录放在这里太长了,附目录链接大家可以自由选择查看--------Java学习目录 SpringMvc知识 第一篇---->SpringMvc初识|MVC|三层架构 第二篇---->IoC容器上下文和映射请求上下文 1 引入 看过第一篇的小伙伴不知是否还记得web.xml中配置的内容呢?重新贴一下配置内容回顾一下    当时入门案例里面用不到SpringIOC容器,所以SpringIOC容器的初始化时被注释掉的,打开注释也没关系,只需要在/WEB-
Spring之IOC详解
weixin_58670730的博客
10-23 1263
1.spring概述 它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-sta
理解IOC
ColorfulChen的博客
07-12 190
IOC
JavaWeb三层架构的配置详解
08-10
JavaWeb三层架构的配置详解 ...JavaWeb三层架构的配置详解中，我们学习了如何配置JavaWeb三层架构，包括软件下载、软件安装和数据库配置等。这种架构设计模式可以使系统具有良好的可维护性、可扩展性和可重用性。
毕业设计基于JavaWeb的宿舍管理系统源码+数据库，基于MVC三层架构
01-17
基于MVC三层架构，主要使用Servlet+JSP+Bootstrap+JQuery+Druid+DBUtils等JavaWeb技术的宿舍管理系统。系统里面分了三个角色，分别为超级管理员、宿舍管理员和学生，每个角色拥有不同的权限和功能； 1.依赖管理使用...
javaWeb学习资料部分---图解版.zip
10-18
5. **监听器（Listener）**: 监听器是观察者模式在JavaWeb中的应用，它们监听特定事件的发生并作出响应。常见的监听器有HttpSessionListener（会话监听）、ServletContextListener（上下文监听）、...
Spring容器启动、IOC、AOP、DI、用户请求流程详解以及循环依赖问题解决流程整体图
想着百万年薪努力的小赵
04-26 438
手写Spring之前先学思想，深入了解Spring源码和了解Spring详细的流程才能写一个Spring框架出来 另外图里有Spring循环依赖问题解决的流程 依赖注入的基本概念： Spring 设计的核心 org.springframework.beans包(架构核心是org.springframework.core包），它的设计目标是与JavaBean组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是BeanFactory接口，它是工厂设计模式的
2-Spring IoC特性(上)
神奇海螺的博客
10-28 151
scope 作用域 spring 管理的 bean 是根据 scope 来生成的，表示 bean 的作用域，共四种。 singleton：单例，表示通过 IoC 容器获取的 bean 是唯一的。 scope 默认为 singleton ApplicationContext ctx=new ClassPathXmlApplicationContext("Spring.xml"); Student student=(Student)(ctx.getBean("student1")); Student
SpringBoot之实体参数的详细解析
qq_69748833的博客
12-13 790
在使用简单参数做为数据传递方式时，前端传递了多少个请求参数，后端controller方法中的形参就要书写多少个。如果请求参数比较多，通过上述的方式一个参数一个参数的接收，会比较繁琐。此时，我们可以考虑将请求参数封装到一个实体类对象中。复杂实体对象指的是，在实体类中有一个或多个属性，也是实体对象类型的。User类中有一个Address类型的属性（Address是一个实体类）上面我们讲的呢是简单的实体对象，下面我们在来学习下复杂的实体对象。参数名和实体类属性名不一致时。参数名和实体类属性名一致时。
IOC简述
weixin_44402870的博客
01-11 1022
ioc面试前必看
Spring笔记(9) - IOC实现方式详解
码猿手
05-09 1万+
　　IOC概念　 　　控制反转（Inversion of Control，IOC），是面向对象编程中的一种设计原则，它建议将不需要的职责移出类，让类专注于核心职责，从而提供松散耦合，提高优化软件程序设计。它把传统上由程序代码直接操控的对象的调用权（new、get等操作对象）交给容器，通过容器来实现对象组件的装配和管理，也就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。　 所以Spring实现IOC的思路是提供一些配置信息用来描述类之间的依赖关系，然后由容器去解析这些配置信息，继而维护好对象之
Spring框架中IoC(控制反转)的原理
热门推荐
茕夜
05-26 4万+
一.IoC的基础知识以及原理： 1.IoC理论的背景：在采用面向对象方法设计的软件系统中，底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。即软件系统中对象之间的耦合，对象A和对象B之间有关联，对象B又和对象C有依赖关系，这样对象和对象之间有着复杂的依赖关系，所以才有了控制反转这个理论。 2.什么是控制反转(IoC)： (1).IoC是Inver
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 853
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
卷积神经网络学习问题总结
weixin_61681867的博客
07-17 636
均方误差函数（MSE）适用于回归任务，如预测房价、预测股票价格等。
kubernetes学习日志（七）
最新发布
qq_47037022的博客
07-18 593
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
理解MVC与三层架构：JavaWeb设计模式解析
"本资源是关于JavaWeb设计模式的讲解，重点探讨了MVC（Model-View-Controller）模型和三层架构在Web应用开发中的应用。作者通过对比Model1和Model2（即MVC）的优缺点，阐述了MVC模式如何提高代码的可维护性和重用性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值