基于Springboot的web后端开发三层架构上手实操

引言

我们拿到了xml文件

我们要将将xml文件中的数据加载并解析

完成数据的处理

并且返回给前端页面(result格式)

1.将xml文件放在resources目录下

xml是我们需要解析的文件

查看xml文件

2.在springboot中引入dom4j依赖

解析xml需要在springboot中引入dom4j依赖

这边我们在springboot工程中已经引入依赖并重新构建了maven

3.引入工具类XmlParserUtils

工具类放入java文件夹下的总包(公司域名反写)的util工具包下

这里引入的是一个解析xml文件的工具类XmlParserUtils

参数是xml文件路径和实例化的类的类型

返回值是list集合

package com.bigdate.threetier_architecture.util;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Constructor;
import java.util.*;
import java.io.File;
import java.util.ArrayList;

public class XmlParserUtils{
    public static <T> List<T> parse(String file,Class<T> targetClass){
        ArrayList<T> list=new ArrayList<T>();
        try {
            //获取一个解析器对象
            SAXReader saxReader=new SAXReader();
            //利用解析器把xml文件加载到内存中 并且返回一个文档对象
            Document document=saxReader.read(new File(file));
            //获取到根标签
            Element rootElement =document.getRootElement();
            //通过根标签来获取user标签
            List <Element> elements=rootElement.elements("emp");

            //遍历集合，得到每一个user标签
            for(Element element:elements){
                //获得name属性
                String name=element.element("name").getText();
                //获得age属性
                String age=element.element("age").getText();
                //获得gender属性
                String gender=element.element("gender").getText();
                //获得job属性
                String job=element.element("job").getText();

                //组装数据
                Constructor<T>constructor=targetClass.getDeclaredConstructor(String.class,Integer.class,String.class,String.class);
                constructor.setAccessible(true);
                T object=constructor.newInstance(name,Integer.parseInt(age),gender,job);

                //把数据添加到集合里面去
                list.add(object);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return  list;
    }
}

4.编写实体类emp和统一响应结果类Result

不管是实体类还是统一响应结果类

我们都将其放在pojo包下

且都是用javabean封装的

实体类emp 标准的javabean 这样就能通过创建对象的方式封装emp的各属性

注意数据类型都是包装类

package com.bigdate.threetier_architecture.pojo;

public class Emp {
    private  String name;
    private  Integer age;
    private String gender;
    private String job;

    public Emp() {
    }

    public Emp(String name, Integer age, String gender, String job) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.job = job;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public Integer getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(Integer age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return job
     */
    public String getJob() {
        return job;
    }

    /**
     * 设置
     * @param job
     */
    public void setJob(String job) {
        this.job = job;
    }

    public String toString() {
        return "Emp{name = " + name + ", age = " + age + ", gender = " + gender + ", job = " + job + "}";
    }
}

统一响应结果result类

这个类主要是给前端页面一个统一响应的响应结果

统一后端返回对象

result类包含三个成员属性和三个静态方法

package com.bigdate.threetier_architecture.pojo;

public class Result {

    private Integer code;
    //响应的状态码
    private String msg;
    //响应的信息 如success
    private Object data;
    //响应回的数据 数据类型为Object

    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 String toString() {
        return "Result{code = " + code + ", msg = " + msg + ", data = " + data + "}";
    }

    //定义静态方法 帮助我们快速构建result对象

    //有数据时响应成功返回 会自动补齐其他参数
    public static Result success(Object data){
        return new Result(1,"success",data);
    }
    
    //没有任何数据返回 即使成功返回成员属性data也是null 
    public static Result success(){
        return new Result(1,"success",null);
    }

    //响应的信息多种多样 仅仅返回响应信息 应该直接放到成员属性的位置
    public static Result success(String msg){
        return new Result(1,msg,null);
    }
}

架构展示

5.数据 -- dao层

我们采用的面向接口的编程方式

先写规则接口然后用实现类去填充

接口

package com.bigdata.dao;

import com.bigdata.pojo.Emp;

import java.util.List;

/*
* 面向接口编程
* 接口的实现类必须重写接口里的所有方法
* 如应对以后我们从不同地方拿到数据 如xml 本地文件 数据库 服务器
* 所以我们先写接口 定义统一的规则 就是从哪里拿取数据
* 之后通过创建接口实现类的方式从指定地方拿取数据
* */

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

实现类实现了接口并重写了方法

加载了xml文件调用工具类XmlParserUtils来解析

package com.bigdata.dao.impl;

import com.bigdata.dao.EmpDao;
import com.bigdata.pojo.Emp;
import com.bigdata.util.XmlParserUtils;

import java.util.List;

//接口的实现类A
public class EmpDaoA implements EmpDao {
    @Override
    public List<Emp> listEmp() {
        //1.加载并解析xml文件
        String file=this.getClass().getClassLoader().getResource("emp.xml").getFile();
        System.out.println(file);
        List<Emp> empList=XmlParserUtils.parse(file, Emp.class);
        return empList;
    }

}

6.核心逻辑 -- service层

最主要的一层

接口与刚刚一样接口中只有一个属性集合

说明我们在service层中的实现类中依然是要对存储在list内的数据进行处理

package com.bigdata.service;

import com.bigdata.pojo.Emp;

import java.util.List;

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

接口的实现类处理代码的核心逻辑

其中我们的list集合从dao层获取

我们要获取的集合就是那个从service层接口的实现类已经处理好的集合

package com.bigdata.service.impl;

import com.bigdata.dao.EmpDao;
import com.bigdata.dao.impl.EmpDaoA;
import com.bigdata.pojo.Emp;
import com.bigdata.service.EmpService;

import java.util.List;

public class EmpServiceA implements EmpService {
    //service层拿取集合要从dao层获取 调用dao获取数据
    private EmpDao empDao=new EmpDaoA();
    @Override
    public List<Emp> listEmp() {
        //拿到dao对象
        List<Emp> empList=empDao.listEmp();
        //2.对数据进行转换处理
        empList.stream().forEach(emp ->{

            //处理gender
            String gender=emp.getGender();
            if(gender.equals("1")){
                emp.setGender("男");
            }else emp.setGender("女");

            //处理job
            String job=emp.getJob();
            if(job.equals("1")){
                emp.setJob("学生");
            }else emp.setJob("老师");

        });
        return empList;
    }
}

7.控制器 -- controller层

不需要书写接口

我们将前dao层和service处理的数据已经放到集合里面去

我们要将集合返回而这个集合去service层中去拿

service层的集合又是从dao层获取的并经过逻辑处理的

package com.bigdata.controller;

import com.bigdata.pojo.Emp;
import com.bigdata.pojo.Result;
import com.bigdata.service.EmpService;
import com.bigdata.service.impl.EmpServiceA;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class Controller {

    private EmpService empService=new EmpServiceA();

    @RequestMapping("/listEmp")
    public Result list(){

        //调用service响应数据 再响应数据
        List<Emp> empList=empService.listEmp();

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

}