SpringBoot 搭建优雅项目，配置简单快速脚手架

首先一首隔壁的泰山打开了局面  嗷～

 

本篇文章，都是偏于自己理解 ( 如果理解有误请大佬们踊跃指出问题 )    吧啦吧啦～

 本文是通过restful风格定义url，让地址看起来非常优雅

 项目结构是通过整理之后的，也非常优雅 （ 还有许多好用的小插件 ）

 好了先介绍一下咱们今天要介绍的主角 SpringBoot  （ 来搭建一套我认为比较好的脚手架 ） --臭不要脸

               1) IDEA          使编码变简单   （专情于jetbrains的ide， 我是一个没有它就不会开发的人儿～ ）

               2) Spring Boot使配置变简单

               3) Spring Boot使部署变简单

   接下来我会非常详细的给大家讲解每一步的操作，从零开始一步一步(有点啰嗦，你可能需要一杯咖啡) ，详细的为大家讲解

   上面所说的 3 个优点我会在项目里为大家体现  认真看！！！

---

Action ：

  首先你需要一个 IDEA 可以去官网下载这里就不详细介绍了哈  (主要考验大家的动手能力，如果你们都很凶的话我会在后面补上)

  打开你的IDEA  File → new → project   ( 本次使用的是jdk 1.8 )

  →  NEXT

  

 

然后会出现一个界面 咳咳 

 简单介绍一下哈～

GroupID是项目组织唯一的标识符，分为多个段，这里我只说两段，第一段为域，第二段为公司名称(或个人名)。

ArtifactID就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称。   

Name就是你项目的名字 

Package就是你项目的包的结构 

→  NEXT

    

接下来你看到的界面是SpringBoot配置jar包的地方 ，本次就不在这里配置了(为了广大民众，我这老母亲的心啊)

熟练之后可以在这里进行基本配置。

→  NEXT

 

然后 ，我们换一首歌

project name: 是项目的名称

project location : 是项目储存的路径

→  Finis

---

 

好了，项目已经生成了 我们来进行配置

非常激动给大家介绍IDEA ，还记得我之前说的这句话么 

IDEA          使编码变简单   （专情于jetbrains的ide， 我是一个没有它就不会开发的人儿～ ）

现在进行项目的基本配置  

打开你们idea的Settings配置文件，在左上角搜索maven

 

简单介绍一下哈～

Maven home directory : 你下载maven 的位置

User setting file            : maven 下的 conf 文件中的settings.xml文件 （勾选上图标记的地方进行选择）

Local repository           : maven  下的 本地仓库地址

  →  OK

如果上面的内容我没有阐述清楚的话大家见谅一下可以简单搜索一下maven的配置

简单看一下我们项目的结构  （还没有动工的） 

打开我们的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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bobo</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot</name>
    <description>Demo project for Spring Boot</description>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--Starter主要用来简化依赖用的。比如我们之前做MVC时要引入日志组件，那么需要去找到log4j的版本，
            然后引入，现在有了Starter之后，直接用这个之后，log4j就自动引入了，也不用关心版本这些问题-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!--spring-boot 测试模块用的-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--spring-boot web项目需要引用的jar包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--spring-boot 配置druid数据源 （它是连接数据库的）-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <!--spring-boot 配置mybatis 这个我就不详细介绍了-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!--spring-boot 配置pagehelper 非常好用的分页小插件 我会在接下来的项目中给大家演示-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>

        <!--spring-boot 配置mapper 通用mapper 这个无敌 神级jpa-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.1.0</version>
        </dependency>

        <!--工具包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <!--mysql的连接池-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

 

导入相应的maven依赖之后点一下引入jar包的操作 （IDEA会有提示）下图标注的地方

 

接下来我们搭一下我们项目的整体架构  

 

建立好相应的目录结构（重点！）

简单说一下每个目录的作用

文件名	作用
src	根目录  下面有 main /  test
main	主目录 用于存放Java 和 资源
java	存放java代码 和包
resource	存放资源文件和静态文件夹
resource/mapper	存放dao中每个方法对应的sql
static	springboot 默认的(jsp, html 吧啦吧啦～)

接下来是我们在 java 里所建的包

包名	作用
controller	控制器，用来控制url过来的请求
service	业务逻辑（接口） 设计业务逻辑
serviceImpl	业务逻辑（实现） 写我们所对应的业务逻辑接口
mapper	数据访问层（接口） 目前用作数据库交互操作，可以用mabatis配置和我们的xml文件里面的方法对应
entity	实体类 和数据库表中的字段对应
exception	异常： 自己定义的异常，因为有些业务逻辑会给代码产生bug我们自己抛出  （以后会给大家讲解）
param	查询： 又是web会传一些字段让我们在数据库查询 （我要是没阐述清楚会在下面项目中对大家进行讲解）

 

下面真的要开始进行编码工作了，坚持到这里辛苦大家了~

首先配置我们的application.yml 

•     我们本次是使用 application.yml 进行配置的 
•     springboot 有两种基本配置 一个是application.properties 和 application.yml 

这也是springboot非常方便的一点 它把我们需要的都集成在了一起，省略了很多配置 

删除 application.properties 在resources重新见一个 application.yml  （如下 两图 ）

 

application.yml ：

​
# springboot 自带的tomcat端口号
server:
  port: 8881

#  spring druid 配置数据源本次使用的是mysql
spring:
  #连接池配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
#  配置连接池属性
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/zuyunbo
      username: root
      password: 123456


mybatis:
  # mybatis扫描 使得数据库字段和实体对应
  type-aliases-package: com.bobo.springboot.eneity
  # 我们xml 所存储的地方
  mapper-locations: classpath:mapper/*.xml


  configuration:
    #使用jdbc的getGeneratekeys获取自增主键值
    use-generated-keys: true
    #开启mybatis缓存策略
    cache-enabled: false
    #开启驼峰命名转换       如数据库  user_name  对应实体  userName
    map-underscore-to-camel-case: true

#分页插件 很好用可以先去了解一下 我们会在接下来的项目讲解
pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql

# 神器 通用mapper 会在接下来的项目详解
mapper:
  mappers:
    - tk.mybatis.mapper.common.Mapper
  not-empty: true

​

我们已经完成了springboot的大部分配置

SpringBoot项目的Bean装配默认规则是根据Application类所在的包位置从上往下扫描！

这就是springboot的配置（刚开始有可能不太习惯，用熟了就好了，I know you）

---

下面来创建我们的数据库

 schema.sql

-- 用户表
CREATE TABLE `user_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT ,
  `user_name` varchar(100) ,
  `pass_word` int(11) ,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8;

-- 用户表插入信息
INSERT INTO `user_info` (`id`, `user_name`, `pass_word`)
VALUES
    (1, '大盘鸡', 12345678),
    (2, '小龙虾', 234567),
    (3, '火锅', 3456789)



-- 角色表
  CREATE TABLE `role_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT ,
  `name` varchar(100) ,
  `description` varchar(100) ,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8;

-- 用户和角色关联表
  CREATE TABLE `user_role` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT ,
  `user_id` int(10) ,
  `role_id` int(10) ,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户角色表';

现在我们将在common包里创建一些公共的实体 （来优雅的了）

首先来说明作用： 

文件名	作用
BaseEntity	公共实体类，用来存放实体的共同的参数    如 id
BaseQueryParam	公共查询累，用来存放查询的共同参数     如ps,pn
BaseResponseUtil	返回基类，用来作为返回给web端的对接信息   （失败或者成功）
BaseServiceInterface	公共接口类，用来存放基本方法 如 crud 方法，分页方法

下面给大家看一下代码 有一个大概印象，一会就会体会到强大之处

BaseEntity：

package com.bobo.springboot.common;


import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;

/**
 * 公共实体类    这里的id注意要在数据库声明自增长
 */
public class BaseEntity implements Serializable {

    private static final long serialVersionUID = 4188086172919649925L;

    @Id
    @Column(insertable = false, updatable = false)   // 在插入数据库和修改数据库时 id字段不做操作
    @GeneratedValue(strategy = GenerationType.IDENTITY) //数据库在插入数据时,数据库会自动给主键赋值 无需我们管理
    private Long id;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

BaseQueryParam：

package com.bobo.springboot.common;

/**
 * 公共查询类
 */
public class BaseQueryParam {

    private int ps;   //每页行数

    private int pn;   //当前页数

    /**
     * 还可以加一些常用的查询参数 ，用于统一规范处理
     * 如: private String creDate;
     */


    public int getPs() {
        return ps;
    }

    public void setPs(int ps) {
        this.ps = ps;
    }

    public int getPn() {
        return pn;
    }

    public void setPn(int pn) {
        this.pn = pn;
    }
}

BaseResponseUtil：

package com.bobo.springboot.common;

import java.util.HashMap;
import java.util.Map;

/**
 *  返回基类
 */
public class BaseResponseUtil {

    /**
     * 请求成功
     */
    public static final int SUCCESS = 1;

    /**
     * 请求异常
     */
    public static final int FAILED = -1;


    public static Map<String, Object> constructResponse(int code, String msg) {
        Map<String, Object> jo = new HashMap<>(3);
        jo.put("code", code);
        jo.put("msg", msg);
        jo.put("data", null);
        return jo;
    }

    public static Map<String, Object> constructResponse(int code, String msg, Object data) {
        Map<String, Object> jo = new HashMap<>(3);
        jo.put("code", code);
        jo.put("msg", msg);
        jo.put("data", data);
        return jo;
    }
}

BaseServiceInterface：

package com.bobo.springboot.common;

import com.github.pagehelper.PageInfo;

import java.util.List;

/**
 * 公共接口类
 */
public interface BaseServiceInterface<T, Q, Z> {

    /**
     * 新增
     *
     * @param entity 新增实体
     * @return 操作行数
     */
    int save(T entity);

    /**
     * 修改
     *
     * @param entity 修改实体
     * @return 操作行数
     */
    int update(T entity);

    /**
     * 删除
     *
     * @param id 主键
     * @return 操作行数
     */
    int remove(Z id);

    /**
     * 主键查询
     *
     * @param id 主键
     * @return 查询结果
     */
    T getById(Z id);

    /**
     * 查询分页集合
     *
     * @param queryParam 查询条件封装实体
     * @return 查询结果
     */
    PageInfo<T> pageQuery(Q queryParam);

    /**
     * 查询集合
     *
     * @param queryParam 查询条件封装实体
     * @return 查询结果
     */
    List<T> listQuery(Q queryParam);

}

建造完这些基本的项目框架结构就可以来写我们的业务和需求了  ，

下面我们就开始我们的业务代码 ，

 首先在entity包中建立三个实体代码  RoleInfo UserInfo UserRole

这里我就简化了对实体的构造，以便大家方便阅读， 重要的也不是对于实体的结构理解，而是对项目的整体架构有一个简单大体的概念，追求在工作中打造出快速；便捷；优雅；便于开发的项目。

UserRole：

package com.bobo.springboot.entity;

import com.bobo.springboot.common.BaseEntity;

/**
 * 用户实体
 */
public class UserInfo extends BaseEntity {

    private String userName;

    private Integer passWord;

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserName() {
        return userName;
    }

    public void setPassWord(Integer passWord) {
        this.passWord = passWord;
    }

    public Integer getPassWord() {
        return passWord;
    }

}

RoleInfo：

package com.bobo.springboot.entity;

import com.bobo.springboot.common.BaseEntity;

/**
 * 角色实体
 */
public class RoleInfo extends BaseEntity {

    private String name;

    private String description;


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

    public String getName() {
        return name;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

UserRole：

package com.bobo.springboot.entity;

import com.bobo.springboot.common.BaseEntity;

/**
 *  角色与用户关联表
 */
public class UserRole extends BaseEntity {

    private Integer userId;

    private Integer roleId;


    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public Integer getRoleId() {
        return roleId;
    }
}

仔细观察上面三个实体你会发现他们自己的实体中是没有 id这个字段的，而在BaseEntity进行统一管理的，这就是BaseEntity的作用，如果大家在开发中有相同的成员，都是可以进行管理的，与web端对接也会规范起来。

接下来建立我们的查询实体，里面放的字段是由web端传 → 后台用实体接受 方便管理

建立RoleInfoQueryParam，UserInfoQueryParam，UserRoleQueryParam

RoleInfoQueryParam：

package com.bobo.springboot.param;

import com.bobo.springboot.common.BaseQueryParam;

// 查询
public class RoleInfoQueryParam extends BaseQueryParam {
    
}

UserInfoQueryParam：

package com.bobo.springboot.param;

import com.bobo.springboot.common.BaseQueryParam;


public class UserInfoQueryParam extends BaseQueryParam {
    //按照用户名查询 
    private String name;

    public String getName() {
        return name;
    }

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

UserRoleQueryParam:

package com.bobo.springboot.param;

import com.bobo.springboot.common.BaseQueryParam;


public class UserRoleQueryParam extends BaseQueryParam {}

上面大家也会发现都继承了一个BaseQueryParam类， 里面就放着这些共有的成员： ps, pn  或者根据你们的业务需求可能会有很多模块都需要的查询成员 如按日期查询 creDate   或者 balabal ...

下面开始我们的建立与数据库交互的接口具体实现方法就是所对应的 xxx.xml 

建立  RoleInfoMapper ， UserInfoMapper ， UserRoleMapper

UserInfoMapper：

package com.bobo.springboot.mapper;
import com.bobo.springboot.entity.UserInfo;
import com.bobo.springboot.param.UserInfoQueryParam;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;

@Repository
public interface UserInfoMapper extends  Mapper<UserInfo>  {

 List<UserInfo> listQuery(UserInfoQueryParam queryParam);

}

RoleInfoMapper：

package com.bobo.springboot.mapper;

import com.bobo.springboot.entity.RoleInfo;
import com.bobo.springboot.param.RoleInfoQueryParam;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;


@Repository
public interface RoleInfoMapper extends Mapper<RoleInfo> {

    List<RoleInfo> listQuery(RoleInfoQueryParam queryParam);

}

UserRoleMapper：

package com.bobo.springboot.mapper;

import com.bobo.springboot.param.UserRoleQueryParam;
import com.bobo.springboot.entity.UserRole;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;


@Repository
public interface UserRoleMapper extends Mapper<UserRole> {

    List<UserRole> listQuery(UserRoleQueryParam queryParam);

}

这里要介绍的就是我们之前所说的神器通用Mapper , 仔细看我们上面接口里面只有一个listQuery方法， 那其余的crud方法都是由继承的Mapper里面进行实现  这样你只要继承了Mapper类就会获得基本的方法，剩下不满足我们的业务方法再由自己编写，会省了很多开发时间。通用 ！通用！ 通用！

这里上面的listQuery方法是本人自己写的用来 按照字段查询集合的 

注意一点在我们所建立的三个Mapper接口中在类上面会有一个@Repository注解 这个注解是用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组。 在我们以前的项目中需要配置myBatis扫描，但是在我们的springBoot中你只需要 在开始类SpringbootApplication中添加  @MapperScan(basePackages = {"com.bobo.springboot.mapper"})  自己定义的mapper包（mapper包下的接口 与 xxx.xml 文件中的 namespace: xxx 对应） 如下图：

package com.bobo.springboot;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = {"com.bobo.springboot.mapper"})
public class SpringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

接下来写我们的service层和impl实现层 因为需要我们只写userInfo的 service和serviceImpl类  

坚持到这里很感谢你的支持，加油，加油，在加油。

在service层建立 UserInfoService 在 service/impl 路径中建立 UserInfoServiceImpl

UserInfoService：

package com.bobo.springboot.service;

import com.bobo.springboot.common.BaseServiceInterface;
import com.bobo.springboot.entity.UserInfo;
import com.bobo.springboot.param.UserInfoQueryParam;


public interface UserInfoService extends BaseServiceInterface<UserInfo,UserInfoQueryParam,Long> {
}

你们可能会纳闷我的UserInfoService中怎么没有方法呢？ 下面给大家介绍BaseServiceInterface类，这个类利用泛型来管理我们所要实现的一些基本方法，如：增；删；该；查， 基本逻辑。 就不需要每次在我们的各个模块service中重复定义，只需要把对应的实体 ，查询对象，和id的类型 交给我们的BaseServiceInterface ，然后在我们的 UserInfoServiceImpl 中会实现公共接口类定义的基本方法 再介绍我们的实现类之前我们先完成一个小操作：（之前说过的 exception 包）

在exception包里创建我们自己的异常 IllegalParameterException 业务异常类（都需要继承RuntimeException）

package com.bobo.springboot.exception;

/**
 * 自己定义的异常 需实现RuntimeException 在Impl中会用到
 */
public class IllegalParameterException extends RuntimeException {

    public IllegalParameterException(String exception) {
        super(exception);
    }
}

接下来创建我们的UserInfoServiceImpl类 实现 UserInfoService

UserInfoServiceImpl：

package com.bobo.springboot.service.impl;

import com.bobo.springboot.exception.IllegalParameterException;
import com.bobo.springboot.mapper.UserInfoMapper;
import com.bobo.springboot.entity.UserInfo;
import com.bobo.springboot.param.UserInfoQueryParam;
import com.bobo.springboot.service.UserInfoService;;
import org.springframework.beans.factory.annotation.Autowired;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserInfoServiceImpl implements UserInfoService {

    @Autowired
    UserInfoMapper userInfoMapper;

    @Override
    public int save(UserInfo entity) {
        return userInfoMapper.insert(entity);
    }

    @Override
    public int update(UserInfo entity) {
        if (entity.getId() == null || entity.getId() == 0L) {
            // 自己定义的异常方法
            throw new IllegalParameterException("更新内容id不能为空");
        }

        return userInfoMapper.updateByPrimaryKeySelective(entity);
    }

    @Override
    public int remove(Long id) {
        if (id == null || id == 0L) {
            // 自己定义的异常方法
            throw new IllegalParameterException("删除操作id不能为空");
        }


        return userInfoMapper.deleteByPrimaryKey(id);
    }

    @Override
    public UserInfo getById(Long id) {
        if (id == null || id == 0L) {
            // 自己定义的异常方法
            throw new IllegalParameterException("详情id不能为空");
        }

        return userInfoMapper.selectByPrimaryKey(id);
    }

    // 分页方法
    @Override
    public PageInfo<UserInfo> pageQuery(UserInfoQueryParam queryParam) {
        // ps pn 都是公共查询方法力的参数   这是分页插件 很好用的插件～
        PageHelper.startPage(queryParam.getPn(), queryParam.getPs());
        // 自己在mapper里定义的查询集合方法
        List<UserInfo> list = userInfoMapper.listQuery(queryParam);
        PageInfo<UserInfo> page = new PageInfo<>(list);
        return page;
    }

    @Override
    public List<UserInfo> listQuery(UserInfoQueryParam queryParam) {
        return userInfoMapper.listQuery(queryParam);
    }
}

在这里我们实现了最基本的增，删，该，查，分页方法 如果我们在项目中有其他业务逻辑只需在里面补充即可

在我们实现类里有一个pageQuery方法是分页方法 使用PageHelper实现的 如果大家有兴趣可以去了解一下

下面进行我们的最后一步,建立我们controller类，用来控制url过来的请求在这个类里会有一些和以往的项目不同，仔细看我在类里标注的备注，认真看！！！ 

 本次建立的项目 是返回json格式的 不是返回页面的 

package com.bobo.springboot.controller;

import com.bobo.springboot.common.BaseResponseUtil;
import com.bobo.springboot.param.UserInfoQueryParam;
import com.bobo.springboot.service.UserInfoService;
import com.bobo.springboot.entity.UserInfo;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

// 以前的项目如果想要让方法返回json格式的 就需要在每个方法之上定义@ResponseBody 注解

// 由于在RestController注解中包含 @Controller @ResponseBody 双注解 就不需要在每个方法上定义@ResponseBody注解

@RestController
@RequestMapping("/user/userInfo")  // 获取url控制 如：localhost:8080/user/userInfo 就会访问到本类中
public class UserInfoController {

    // 本次url是请求适用于restful 风格 所以请求方法会有一点变化 并不是以前的GetMapping() 
    
    @Autowired
    UserInfoService userInfoService;

    @PostMapping(value = "/save")  //restful 风格的 如果不懂可以先去了解一下  
    public Object save(@RequestBody UserInfo entity) {
        int result = userInfoService.save(entity);

        if (result > 0) {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.SUCCESS, "保存成功", entity.getId());
        } else {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.FAILED, "保存失败", result);
        }
    }

    @GetMapping(value = "/{id}/detail")  //restful 风格的 如果不懂可以先去了解一下  
    public Object detail(@PathVariable long id) {
        UserInfo entity = userInfoService.getById(id);
        return BaseResponseUtil.constructResponse(BaseResponseUtil.SUCCESS, "查询成功", entity);
    }

    @PutMapping(value = "/update")    //restful 风格的 如果不懂可以先去了解一下  
    public Object update(@RequestBody UserInfo entity) {
        int result = userInfoService.update(entity);

        if (result > 0) {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.SUCCESS, "修改成功", entity.getId());
        } else {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.FAILED, "修改失败");
        }
    }

    @DeleteMapping(value = "/{id}")   //restful 风格的 如果不懂可以先去了解一下  
    public Object remove(@PathVariable long id) {
        int result = userInfoService.remove(id);

        if (result > 0) {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.SUCCESS, "删除成功");
        } else {
            return BaseResponseUtil.constructResponse(BaseResponseUtil.FAILED, "删除失败");
        }
    }

    @GetMapping(value = "/list")    //restful 风格的 如果不懂可以先去了解一下  
    public Object list(UserInfoQueryParam queryParam) {
        PageInfo pageInfo = userInfoService.pageQuery(queryParam);

        return BaseResponseUtil.constructResponse(BaseResponseUtil.SUCCESS, "查询成功", pageInfo);
    }
}

好的接下来建立我们的resources/mapper/下的.xml文件 

RoleInfoMapper.xml ，UserInfoMapper.xml，UserRoleMapper.xml

UserInfoMapper.xml：

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bobo.springboot.mapper.UserInfoMapper">
    <cache readOnly="true" eviction="FIFO"/>


    <select id="listQuery" parameterType="UserInfoQueryParam" resultType="UserInfo">
        SELECT * FROM user_info
        <where>
            <if test="name!=null and name!=''">
                user_info.name = #{name}
            </if>
        </where>
    </select>

</mapper>

RoleInfoMapper.xml:

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bobo.springboot.mapper.RoleInfoMapper">
    <cache readOnly="true" eviction="FIFO"/>


    <select id="listQuery" parameterType="RoleInfoQueryParam" resultType="RoleInfo">
        SELECT * FROM role_info
    </select>

</mapper>

UserRoleMapper.xml:

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bobo.springboot.mapper.UserRoleMapper">
    <cache readOnly="true" eviction="FIFO"/>


    <select id="listQuery" parameterType="UserRoleQueryParam" resultType="UserRole">
        SELECT * FROM user_role
    </select>

</mapper>

注意：这里的 namespace 是和你之前定义的 Mapper 所对应的路径

是的 ，你会发现比以前项目少个一个标签 <resultMap> 因为我们在 application.yml 配置 mybatis 项中声明过 这里的type-aliases-package 就是我们返回的实体 不需要在建立 <resultMap>  直接用  resultType=" xxx "  定义返回实体映射就可以了

还有这里的查询 parameterType： 就是我们自己定义的查询方法 也会由下面配置进行扫描

接下来大功告成，下面启动我们的项目刺激刺激一下我们自己

我们在.yml设置的端口号为8881

启动发射 ：

看到了 已经成功了 端口号为8881  接下来打开网页访问我们的项目地址 http://localhost:8881/user/userInfo/list 

好了，我们完整的框架整合配置，与应用实例部分已经结束了，我把所有源码和jar包一起打包放在了我的GitHub上，需要的可以去下载，喜欢就给个star吧。（我会在这几天上传）

更新 ：

https://github.com/zuyunbo/springboot/tree/master

github地址，如项目有问题可以回复我，或者想看什么系列文章

如有问题我会及时回复，以免误导别人 （辛苦了大家）

如果文章对你有帮助，可以支持一下我，我会继续为大家辛苦写出文章的 谢谢

如果大佬们可以的话，给个打赏吧

                                             剧终

更新：   2018*-09-06

特征&提供

• 最佳实践的项目结构、配置文件、精简的POM（查看项目结构图）
• 统一响应结果封装及生成工具
• 简单的接口签名认证
• 常用基础方法抽象封装
• 使用Druid Spring Boot Starter 集成Druid数据库连接池与监控
• 集成MyBatis、通用Mapper插件、PageHelper分页插件，实现单表业务零SQL

 

下期更新shiro权限登录 可继承jwt    敬请期待

     利用jdbc  file代码生成