Java持久层和控制器的封装

心已赠人 2023-06-24 15:24 206阅读 0赞

### 持久层和控制器的封装 ###

在平时开发中，会有很多单表或者多表的增删改查功能，仔细看会发现，持久层和控制器的代码基本差不多。如果我们把持久层和控制器增删改查这种重复性高的代码全部提取出来，做一个小封装，这样在开发中是不是就可以减少很多代码量了。从而提高开发效率。

这里案例持久层使用的是Spring-Data-Jpa

新建一个SpringBoot项目，选择需要使用到的依赖。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70][]

项目中所有的依赖pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.2.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.mcy</groupId>
        <artifactId>springboot-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-demo</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

在application.properties文件中配置数据库的链接。

spring.datasource.url=jdbc:mysql://localhost:3306/springbootdemo?serverTimezone=GMT%2B8
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
    spring.jpa.show-sql=true
    spring.jpa.hibernate.ddl-auto=update
    spring.jpa.hibernate.use-new-id-generator-mappings=false
    
    spring.servlet.multipart.max-request-size=2048MB
    spring.servlet.multipart.max-file-size=2048MB
    
    server.port=8080

在写代码之前，我们先来看一下项目的目录结构。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 1][]

**代码实现**

对持久层的封装，我们首先需要确定的就是找到对应的实体类，之后才能对其进行操作，可以通过反射机制找到当前的实体类。

新建一个反射工具类GenericsUtils，**这个类很重要**，可以帮助我们找到对应的实体类。

import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    
    public class GenericsUtils {
        /**
         * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends
         * GenricManager<Book>
         * 
         * @param clazz The class to introspect
         * @return the first generic declaration, or <code>Object.class</code> if cannot be determined
         */
        public static Class getSuperClassGenricType(Class clazz) {
            return getSuperClassGenricType(clazz, 0);
        }
    
        /**
         * 通过反射,获得定义Class时声明的父类的范型参数的类型. 如public BookManager extends GenricManager<Book>
         * 
         * @param clazz clazz The class to introspect
         * @param index the Index of the generic ddeclaration,start from 0.
         */
        public static Class getSuperClassGenricType(Class clazz, int index)
                throws IndexOutOfBoundsException {
            Type genType = clazz.getGenericSuperclass();
            if (!(genType instanceof ParameterizedType)) {
                return Object.class;
            }
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
            if (index >= params.length || index < 0) {
                return Object.class;
            }
            if (!(params[index] instanceof Class)) {
                return Object.class;
            }
            return (Class) params[index];
        }
    }

新建CommonRepository接口，为公共的Reposit接口，该类继承JpaRepository，JpaSpecificationExecutor两个接口，这两个接口中包含了基本的查询。之后在新建Repository就可以直接继承这个公共的CommonRepository接口就可以了，有两个泛型接口，实体类名称和id的类型，T表示实体类名称，ID表示id的类型。代码如下。

@NoRepositoryBean
    public interface CommonRepository<T,ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T> {
    
    }

新建CommonService类，为公共的Server类，包含了一下基本查询的方法，之后的Server类，只需要继承这个类，就会包含CommonService类中的所有查询方法，不用在每个类都去写一遍，如果有需要更改的话，可以重写继承类中的方法。和Repository接口一样，它也有有两个泛型接口，实体类名称和id的类型，T表示实体类名称，ID表示id的类型。代码如下。

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.Pageable;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.jpa.domain.Specification;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.util.List;
    import java.util.Optional;
    
    /**
     * 公共Service
     * @param <T>
     * @param <ID>
     */
    public class CommonService<T,ID> {
    	@Autowired(required = false)
    	private CommonRepository<T, ID> baseDAO;
    
    	//查询所有
    	public List<T> findAll(){
    		return baseDAO.findAll();
    	}
    
    	//根据id查询
    	public T findById(ID id) {
    		Optional<T> optional = baseDAO.findById(id);
    		if(optional.isPresent()) {
    			return optional.get();
    		}
    		return null;
    	}
    
    	//保存方法
    	@Transactional
    	public void save(T entity) {
    		baseDAO.save(entity);
    	}
    
    	//根据实体类删除
    	public void delete(T entity) {
    		baseDAO.delete(entity);
    	}
    
    	//根据id查询
    	@Transactional
    	public void deleteById(ID id) {
    		baseDAO.deleteById(id);
    	}
    
    	//排序查询所有
    	public List<T> findAll(Sort sort){
    		return baseDAO.findAll(sort);
    	}
    
    	//动态条件查询
    	public List<T> findAll(Specification<T> spec){
    		return baseDAO.findAll(spec);
    	}
    
    	//分页查询
    	public Page<T> findAll(Pageable pageable){
    		return baseDAO.findAll(pageable);
    	}
    
    	//动态条件分页查询
    	public Page<T> findAll(Specification<T> spec, Pageable pageable){
    		return baseDAO.findAll(spec,pageable);
    	}
    
    	//动态条件排序查询
    	public List<T> findAll(Specification<T> spec, Sort sort){
    		return baseDAO.findAll(spec,sort);
    	}
    }

最后就是控制器的封装了，控制器需要先通过反射机制的工具类GenericsUtils，找到对应的实体类。之后封装一下常用的方法。不同于上面两个类的是，他有三个泛型接口，除了实体类和ID的类型外，他还有一个BaseForm类，BaseForm为公共的Form类，该类中就一个id和一个查询条件。因为这里写数据保存方法的数据接收是很使用的Form接收的，使用Form里边的ID是判断是修改还是新增方法（修改和新增用的一个方法，用id是否为null区分），BaseForm类代码如下。

public class BaseForm<ID> {
    	private ID id;
    	private String search;
    	
    	public ID getId() {
    		return id;
    	}
    
    	public void setId(ID id) {
    		this.id = id;
    	}
    
    	public String getSearch() {
    		return search;
    	}
    
    	public void setSearch(String search) {
    		this.search = search;
    	}
    	
    }

其中search字段是BootstrapTable查询传递参数的属性名，所以写在了公共的Form类中，不需要的可以删除不要。

公共的CommonController控制器代码如下（主要包了数据显示，新增修改页面的跳转，和数据查询和删除的方法）。

import org.springframework.beans.BeanUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.jpa.domain.Specification;
    import org.springframework.ui.ModelMap;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    /**
     * 公共Controller
     * @param <T>
     * @param <ID>
     * @param <Form>
     */
    public class CommonController<T, ID, Form extends BaseForm<ID>>{
    	//通过反射工具类GenericsUtils，获得到实体类
    	@SuppressWarnings("unchecked")
    	private Class<T> clazz = GenericsUtils.getSuperClassGenricType(getClass());
    	
    	@Autowired
    	private CommonService<T, ID> baseService;
    
    	//数据显示页面
    	@RequestMapping(value="/manage")
    	public void manage(ModelMap map) {
    	
    	}
    
    	//修改和新增页面，共用的一个页面
    	@RequestMapping(value="/edit")
    	public void edit(Form form, ModelMap map) throws InstantiationException, IllegalAccessException {
    		T model=clazz.newInstance();
    		ID id = form.getId();
    		if(id!=null) {
    			model=baseService.findById(id);
    		}
    		map.put("model", model);
    	}
    
    	//数据保存方法
    	@RequestMapping(value="/save")
    	@ResponseBody
    	public Object save(Form form)  {
    		try {
    			T model=clazz.newInstance();
    			ID id = form.getId();
    			if(id!=null) {
    				model=baseService.findById(id);
    			}
    			BeanUtils.copyProperties(form, model,"id");
    			baseService.save(model);
    			return new AjaxResult("数据保存成功");
    		} catch (Exception e) {
    			return new AjaxResult(false,"数据保存失败");
    		}
    	}
    
    	//删除方法
    	@RequestMapping(value="/delete")
    	@ResponseBody
    	public Object delete(ID id) {
    		try {
    			baseService.deleteById(id);
    			return new AjaxResult("数据删除成功");
    		} catch (Exception e) {
    			return new AjaxResult(false,"数据删除失败");
    		}
    	}
    	
    	//动态查询方法
    	public Specification<T> buildSpec(Form form){
    		return null;
    	}
    
    	//分页数据查询
    	@RequestMapping(value="/page")
    	@ResponseBody
    	public Object page(TablePageable pageParam,Form form) {
    		PageRequest pageable = pageParam.bulidPageRequest();
    		Specification<T> spec = buildSpec(form);
    		Page<T> page=baseService.findAll(spec, pageable);
    		return AjaxResult.bulidPageResult(page);
    	}
    }

分页查询中的TablePageable类，是用于接收Bootstraptable传递过来的分页参数，代码如下。

import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.domain.Sort.Direction;
    import org.springframework.data.domain.Sort.Order;
    
    /**
     * 分页的一个工具类，接收分页信息
     */
    public class TablePageable {
    	private Integer limit; //分页
    	private Integer offset;//首记录号（从0开始）
    	private String sort;   //排序字段
    	private String order;  //顺序，逆序
    	
    	public Integer getLimit() {
    		return limit;
    	}
    
    	public void setLimit(Integer limit) {
    		this.limit = limit;
    	}
    
    	public Integer getOffset() {
    		return offset;
    	}
    
    	public void setOffset(Integer offset) {
    		this.offset = offset;
    	}
    
    	public String getSort() {
    		return sort;
    	}
    
    	public void setSort(String sort) {
    		this.sort = sort;
    	}
    
    	public String getOrder() {
    		return order;
    	}
    
    	public void setOrder(String order) {
    		this.order = order;
    	}
    
    	
    	public PageRequest bulidPageRequest() {
    		int page=(offset!=null&&limit!=null)?offset/limit:0;
    		int size=limit!=null?limit:10;
    		if(sort==null) {
    			return PageRequest.of(page, size);
    		}else {
    			Order order2=new Order(Direction.fromString(order), sort);
    			Sort sort2= Sort.by(order2);
    			return PageRequest.of(page,size,sort2 );
    		}
    		
    	}
    	
    	public PageRequest bulidPageable(Sort sort) {
    		int page=(offset!=null&&limit!=null)?offset/limit:0;
    		int size=limit!=null?limit:10;
    		return PageRequest.of(page, size, sort);
    	}
    	
    	public Sort bulidSort() {
    		Order order2=new Order(Direction.fromString(order), sort);
    		Sort sort2= Sort.by(order2);
    		return sort2;
    	}
    }

分页查询中返回的AjaxResult类中的bulidPageResult方法是用于转载BootstrapTable表格数据的，根据BootstrapTable接收数据的格式来写。代码如下。

import org.springframework.data.domain.Page;
    
    import java.util.HashMap;
    
    /**
     * 方法执行成功后，返回的工具类
     */
    public class AjaxResult {
    	private Boolean success;
    	private String msg;		//提示信息
    	
    	public Boolean getSuccess() {
    		return success;
    	}
    
    	public void setSuccess(Boolean success) {
    		this.success = success;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    	
    	public AjaxResult(String msg) {
    		super();
    		this.success=true;
    		this.msg = msg;
    	}
    	
    	public AjaxResult(Boolean success, String msg) {
    		super();
    		this.success = success;
    		this.msg = msg;
    	}
    
    	@SuppressWarnings("rawtypes")
    	public static HashMap<String, Object> bulidPageResult(Page page) {
    		HashMap<String, Object> result=new HashMap<>();
    		result.put("total", page.getTotalElements());
    		result.put("rows", page.getContent());
    		return result;
    	}
    
    }

TablePageable类和AjaxResult类，根据自己开发需求来写。

封装文件写完了，下面就需要来写一个案例测试一下了。新建一个User实体类，随便给几个字段，用于测试。代码如下。

import javax.persistence.*;
    
    @Entity
    @Table(name = "tb_user")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id; //主键
        private String username;    //姓名，username
        private String loginName;   //用户名，
        private Integer age;    //年龄
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getLoginName() {
            return loginName;
        }
    
        public void setLoginName(String loginName) {
            this.loginName = loginName;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public User() {
        }
    
        public User(String username, String loginName, Integer age) {
            this.username = username;
            this.loginName = loginName;
            this.age = age;
        }
    }

实体类新建完成后，新建对应的Form接收类，继承BaseForm类，代码如下。

import com.mcy.springbootdemo.custom.BaseForm;
    
    public class UserForm extends BaseForm<Integer> {
        private String username;    //姓名，username
        private String loginName;   //登录名
        private Integer age;    //年龄
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getLoginName() {
            return loginName;
        }
    
        public void setLoginName(String loginName) {
            this.loginName = loginName;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }

新建对应的UserRepository类，继承公共的CommonRepository类，泛型传递对应的实体类和ID类型，代码如下。

import com.mcy.springbootdemo.custom.CommonRepository;
    import com.mcy.springbootdemo.entity.User;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface UserRepository extends CommonRepository<User, Integer> {
    
    }

新建对应的UserService类，继承公共的CommonService类，泛型也是传递对应的实体类和ID类型，代码如下。

import com.mcy.springbootdemo.custom.CommonService;
    import com.mcy.springbootdemo.entity.User;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService extends CommonService<User, Integer> {
    
    }

新建对应的控制器UserController，同样继承公共的CommonController类，泛型传递对应的实体类，ID类型和对应的Form。如果对应的方法有需要改动的，可以重写继承的CommonController类中的方法，比如动态查询，就需要重写CommonController类中的buildSpec方法，代码如下。

import javax.persistence.criteria.*;
    import java.util.ArrayList;
    import java.util.List;
    
    @Controller
    public class UserController extends CommonController<User, Integer, UserForm> {
    
        @Autowired
        private UserRepository userRepository;
    
        @RequestMapping(value = {"/", "index"})
        public String index(){
            return "manage";
        }
    
        @Override
        public Specification<User> buildSpec(UserForm form) {
            Specification<User> spec = new Specification<User>() {
                private static final long serialVersionUID = 1L;
    
                @Override
                public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                    //本集合用于封装查询条件
                    List<Predicate> predicates = new ArrayList<>();
                    if (StringUtils.hasText(form.getSearch())) {
                        Predicate name = cb.like(root.get("loginName"), "%" + form.getSearch() + "%");
                        Predicate username = cb.like(root.get("username"), "%" + form.getSearch() + "%");
                        Predicate or = cb.or(name, username);
                        predicates.add(or);
                    }
                    return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
                }
            };
            return spec;
        }
    }

后台代码就这些了，是不是很简洁，省下了不少代码。

接下来就是两个页面了，一个用于显示数据，一个用于新增和删除数据的页面。数据显示用BootstrapTable显示的，可以根据自己需求更改。

数据显示页面manage.html，代码如下。

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Spring-Data-Jpa持久层和控制器的封装</title>
        <link rel="stylesheet" href="static/bootstrap/dist/css/bootstrap.css" />
        <link rel="stylesheet" href="static/bootstrap-table/dist/bootstrap-table.css" />
        <script src="static/bootstrap-table/dist/jquery.js" ></script>
        <script src="static/bootstrap/dist/js/bootstrap.js" ></script>
        <script src="static/bootstrap-table/dist/bootstrap-table.js" ></script>
        <script src="static/bootstrap-table/dist/locale/bootstrap-table-zh-CN.js" ></script>
    </head>
    <body>
    
    <div id="toolbar" class="btn-group">
        <button type="button" class="btn btn-default" onclick="btn_add()">
            <span class="glyphicon glyphicon-plus"></span>新增
        </button>
        <button type="button" class="btn btn-default" onclick="btn_edit()">
            <span class="glyphicon glyphicon-pencil"></span>修改
        </button>
        <button type="button" class="btn btn-default" onclick="btn_delete()">
            <span class="glyphicon glyphicon-remove"></span>删除
        </button>
    </div>
    
    <div style="margin: 20px;">
        <table id="user_table"></table>
    </div>
    
    <script type="text/javascript">
        $("#user_table").bootstrapTable({
            url: 'page',    //表格数据请求地址
            toolbar: '#toolbar',    //自定义组件
            striped: true,	//隔行换色
            height: tableHeight(),		//设置高度
            pagination: true,	//显示表格的底部工具栏
            sidePagination: 'server',   //client客户端分页，server服务器分页
            pageNumber: 1,		//初始的页数
            pageSize: 10,		//默认每页数据
            pageList: [10, 15, 50, 100],	//设置分页选择每页显示的条数
            search: false,		//定义右上方的搜索框，输入即可以开始搜索
            showColumns: true,	//选列的下拉菜单
            showRefresh: true,	//刷新按钮
            showToggle: true,	//视图切换
            search: true,
            toolbarAlign: 'left',	//自定义按钮位置
            clickToSelect: true,	//点击行选中
            singleSelect: true,		//单选
            queryParams: function (param){	//传递参数
                var params = {};
                params['offset'] = param.offset; // 页码
                params['limit'] = param.limit; // 条数
                params['search'] = param.search; // 搜索内容
                params['sort'] = param.sort; // 排序字段
                params['order'] = param.order; // 排序方式
                return params;
            },
            columns:[{
                checkbox: true    //多选框
            },{
                field: 'id',	//每列的字段名
                title: 'id',	//表头所显示的名字
                halign: 'center',	//表头的对齐方式
                valign: 'middle',	//表格对齐方式居中
                order: 'asc',		//默认排序方式
                sortable: true,		//设置可以排序
                align: 'center'		//表格数据对齐方式
            },{
                field: 'username',
                title: '姓名',
                valign: 'middle',
                halign: 'center',
                align: 'center'
            },{
                field: 'loginName',
                title: '用户名',
                valign: 'middle',
                halign: 'center',
                align: 'center'
            },{
                field: 'age',
                title: '年龄',
                valign: 'middle',
                halign: 'center',
                align: 'center'
            }]
        });
    
        function tableHeight() {
            return $(window).height() - 100;
        }
    
        //新增
        function btn_add(){
            var dialog = $('<div class="modal fade" id="myModal" tabindex="-1" aria-labelledby="myModalLabel"></div>');
            dialog.load("edit");
            $("body").append(dialog);
            /*弹出模态框,绑定关闭后的事件*/
            dialog.modal().on('hidden.bs.modal', function () {
                //删除
                dialog.remove();
                $("#user_table").bootstrapTable('refresh');
            });
        }
    
        //修改
        function btn_edit(){
            var str = $("#user_table").bootstrapTable('getSelections');
            if(str.length != 1){
                alert("请选中一行进行编辑");
                return ;
            }
    
            var dialog = $('<div class="modal fade" id="myModal" tabindex="-1" aria-labelledby="myModalLabel"></div>');
            var id = str[0].id;
            dialog.load("edit?id="+id);
            /*添加到body中*/
            $("body").append(dialog);
            /*弹出模态框,绑定关闭后的事件*/
            dialog.modal().on('hidden.bs.modal', function () {
                //删除模态框
                dialog.remove();
                $("#user_table").bootstrapTable('refresh');
            });
        }
    
        /*删除*/
        function btn_delete(){
            var str = $("#user_table").bootstrapTable('getSelections');
            if(str.length != 1){
                alert("请选中一行进行删除");
            }else{
                if(confirm("确定删除选中这一行吗?")){
                    var id = str[0].id;
                    $.post('delete',{id:id},function(){
                        /* refresh刷新 */
                        $("#user_table").bootstrapTable('refresh');
                        alert("删除成功！");
                    });
                }
            }
        }
    </script>
    
    </body>
    </html>

新增和修改页面edit.html，代码如下。

效果如下。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 3][]

### 案例代码下载 ###

下载地址：[https://github.com/machaoyin/springboot-demo][https_github.com_machaoyin_springboot-demo]

如果对你有帮助，点赞关注一下呗^\_^，留下你的足迹。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191223205424423.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191228103525619.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191228112033770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191228112052897.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjA1MTE2,size_16,color_FFFFFF,t_70
[https_github.com_machaoyin_springboot-demo]: https://github.com/machaoyin/springboot-demo