零基础构建Spring Boot项目

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u011019141/article/details/78786091

Spring Boot Demo (零基础搭建SpringBoot项目)

简介:Springboot modules

基础项目搭建

maven构建项目

1、访问http://start.spring.io/

2、选择构建工具Maven Project、Spring Boot版本1.3.6以及一些工程基本信息,点击“Switch to the full version.”java版本选择1.8,可参考下图所示:

3、点击Generate Project下载项目压缩包

4、解压后,使用eclipse,Import -> Existing Maven Projects -> Next ->选择解压后的文件夹-> Finsh,OK done!

项目结构介绍

Spring Boot的基础结构共三个文件:
    src/main/java 程序开发以及主程序入口
    src/main/resources 配置文件
    src/test/java 测试程序
spingboot建议的目录结果如下:
    com
      +- songfayuan
        +- springBoot
          +- Application.java
          |
          +- dao
          |  
          +- entity
          |
          +- service
          |
          +- controller
          |  +- HelloWorldController.java
          |
    1、Application.java 建议放到根目录下面,主要用于做一些框架配置
    2、entity和dao目录主要用于实体(Entity)与数据访问层(Repository)
    3、service 层主要是业务类代码
    4、controller 负责页面访问控制

引入web模块(基础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.songfayuan</groupId>
    <artifactId>spring-boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot</name>
    <description>SongFayuan project for Spring Boot</description>

    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <!-- 设定java版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <!-- 核心模块,包括自动配置支持、日志和YAML -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency> 
        <!-- 测试模块,包括JUnit、Hamcrest、Mockito -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 支持web的模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <!-- Package as an executable jar -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

编写controller内容

package com.songfayuan.springBoot.controller;

import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 描述:Hello World测试代码
 * @author songfayuan
 * 2017年12月12日上午11:56:12
 */
@RestController
@RequestMapping("hello")
public class HelloWorldController {

    private static final Logger logger = LoggerFactory.getLogger(HelloWorldController.class);

    @RequestMapping("/world")
    public String helloDemo() {
        logger.info("接口/hello/world正在被请求...");

        logger.info("-- This is a primary with logback., Current time {}.", new Date());
        logger.trace("This level is TRACE.");
        logger.debug("This level is DEBUG.");
        logger.debug("This level is DEBUG.", logger.isDebugEnabled());
        logger.info("This level is INFO.");
        logger.info("isInfoEnabled:" + logger.isInfoEnabled());
        logger.warn("This level is WARN.");
        logger.error("This level is ERROR.");
        return "Hello World";
    }

}

配置日志输出

直接在resource下添加logback.xml即可,具体配置内容如下:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--<include resource="org/springframework/boot/logging/logback/base.xml"/>-->

    <!-- 设置log日志存放地址(单环境设置) -->
    <property name="log.base" value="/spring-boot_log/logs" />

    <!-- 控制台日志 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%class:%line] %-5level - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
    </appender>

    <!-- warn日志 appender -->
    <appender name="WARN_OUT" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.base}/warn.log</file>
        <!-- 日志格式 -->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%class:%line] %-5level %logger - %msg%n</pattern>
        </encoder>
        <!-- 日志级别过滤器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>WARN</level>
            <!-- 匹配时的操作:接收(记录) -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作:拒绝(不记录) -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 按天回滚 daily -->
            <fileNamePattern>${log.base}/warn-%d{yyyy-MM-dd HH:mm:ss}.log</fileNamePattern>
            <!-- 最大保存时间:30天-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <!--日志文件最大的大小 -->
        <triggeringPolicy
                class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>256MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!-- error日志 appender -->
    <appender name="ERROR_OUT" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.base}/error.log</file>
        <!-- 日志格式 -->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%class:%line] %-5level %logger - %msg%n</pattern>
        </encoder>
        <!-- 日志级别过滤器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>ERROR</level>
            <!-- 匹配时的操作:接收(记录) -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作:拒绝(不记录) -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 按天回滚 daily -->
            <fileNamePattern>${log.base}/error-%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 最大保存时间:30天-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <!--日志文件最大的大小 -->
        <triggeringPolicy
                class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>256MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
    <!--
    <logger name="org.testMybatis" level="DEBUG" />
    <logger name="java.sql.Connection" level="DEBUG" />
    <logger name="java.sql.Statement" level="DEBUG" />
    <logger name="java.sql.PreparedStatement" level="DEBUG" />
    <logger name="java.sql.ResultSet" level="DEBUG" />
    <logger name="backend" level="DEBUG"/>
    -->
    <!-- 基于INFO级别处理日志:具体控制台或者文件对日志级别的处理还要看所在appender配置的filter,如果没有配置filter,则使用root配置 -->
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="WARN_OUT" />
        <appender-ref ref="ERROR_OUT" />
    </root>
</configuration>

最后,启动Application main方法,至此一个java项目搭建好了,打开浏览器访问http://localhost:8080/hello/world,就可以看到效果了。

单元测试

打开的src/test/下的测试入口,编写简单的http请求来测试。

package com.songfayuan.springBoot.controller;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

/**
 * 描述:单元测试
 * @author songfayuan
 * 2017年12月12日下午3:52:52
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class HelloWorldControlerTests {

    private MockMvc mvc;

    @Before
    public void setUp() throws Exception{
        mvc = MockMvcBuilders.standaloneSetup(new HelloWorldController()).build();
    }

    @Test
    public void getHello() throws Exception{
        mvc.perform(MockMvcRequestBuilders.get("/hello/world").accept(MediaType.APPLICATION_JSON))
        .andExpect(MockMvcResultMatchers.status().isOk())
        .andDo(MockMvcResultHandlers.print())
        .andReturn();
    }

}

到现在为止,SpringBoot基本项目搭建完毕,你可以启动并成功运行程序,接下来,便可以在此基础上扩展更多的功能模块。

mail模块

添加依赖包

在pom.xml中添加依赖包,配置如下:

        <!-- mail模块 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.sun.mail</groupId>
            <artifactId>javax.mail</artifactId>
            <version>RELEASE</version>
        </dependency>
        <!-- 模板引擎 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

添加mail相关配置

在application.properties中添加mail相关配置,如下:

spring.mail.host=smtp.163.com
spring.mail.username=songfayuan1993@163.com
spring.mail.password=123456(密码)
spring.mail.default-encoding=UTF-8

mail.fromMail.addr=songfayuan1993@163.com

创建邮件模板

在resources/templates下创建邮件模板emailTemplate.html,自定义样式如下:

<!DOCTYPE html>
<html lang="zh" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8"/>
        <title>邮件模板</title>
    </head>
    <body>
         您好,这是验证邮件,请点击下面的链接完成验证,<br/>
        <a href="#" th:href="@{ http://www.songfayuan.com/mail/{id}(id=${id}) }">激活账号</a>
    </body>
</html>

编辑mail接口和具体实现

MailService

package com.songfayuan.springBoot.service;

/**
 * 描述:发送邮件接口
 * @author songfayuan
 * 2017年12月13日上午10:51:53
 */
public interface MailService {

    /**
     * 描述:发送普通(文本)邮件
     * @param to
     * @param subject
     * @param content
     * @author songfayuan
     * 2017年12月13日上午11:08:12
     */
    public void sendSimpleMail(String to, String subject, String content);

    /**
     * 描述:发送html邮件
     * @param to
     * @param subject
     * @param content
     * @author songfayuan
     * 2017年12月13日上午11:07:57
     */
    public void sendHtmlMail(String to, String subject, String content);

    /**
     * 描述:发送附件邮件
     * @param to
     * @param subject
     * @param content
     * @param filePath
     * @author songfayuan
     * 2017年12月13日上午11:07:41
     */
    public void sendAttachmentMail(String to, String subject, String content, String filePath);

    /**
     * 描述:发送正文中有静态资源(图片)的邮件
     * @param to
     * @param subject
     * @param content
     * @param resourcePath
     * @param contentId
     * @author songfayuan
     * 2017年12月13日上午11:25:31
     */
    public void sendInlineResourceMail(String to, String subject, String content, String resourcePath, String contentId);

}

MailServiceImpl

package com.songfayuan.springBoot.service.impl;

import java.io.File;

import javax.mail.internet.MimeMessage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import com.songfayuan.springBoot.service.MailService;

/**
 * 描述:发送邮件具体实现类
 * @author songfayuan
 * 2017年12月13日上午11:28:56
 */
@Service
public class MailServiceImpl implements MailService {

    private final Logger logger = LoggerFactory.getLogger(MailServiceImpl.class);

    @Autowired
    private JavaMailSender mailSender;

    @Value("${mail.fromMail.address}")
    private String from;

    @Override
    public void sendSimpleMail(String to, String subject, String content) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(content);
        try {
            mailSender.send(message);
            logger.info("发送普通邮件成功...");
        } catch (Exception e) {
            logger.error("发送普通邮件时发生异常...", e);
        }
    }

    @Override
    public void sendHtmlMail(String to, String subject, String content) {
        MimeMessage message = mailSender.createMimeMessage();
        try {
            MimeMessageHelper helper = new MimeMessageHelper(message, true); //true表示需要创建一个multipart message
            helper.setFrom(from);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content, true);
            mailSender.send(message);
            logger.info("发送html邮件成功...");
        } catch (Exception e) {
            logger.error("发送html邮件时发生异常...", e);
        }
    }

    @Override
    public void sendAttachmentMail(String to, String subject, String content, String filePath) {
        MimeMessage message = mailSender.createMimeMessage();
        try {
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content, true);
            FileSystemResource file = new FileSystemResource(new File(filePath));
            String fileName = filePath.substring(filePath.lastIndexOf(File.separator));
            helper.addAttachment(fileName, file);
            mailSender.send(message);
            logger.info("发送附件邮件成功...");
        } catch (Exception e) {
            logger.error("发送附件邮件时发生异常...", e);
        }
    }

    @Override
    public void sendInlineResourceMail(String to, String subject, String content, String resourcePath, String contentId) {
        MimeMessage message = mailSender.createMimeMessage();
        try {
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content, true);
            FileSystemResource resource = new  FileSystemResource(new File(resourcePath));
            helper.addInline(contentId, resource);
            mailSender.send(message);
            logger.info("发送嵌入静态资源的邮件成功...");
        } catch (Exception e) {
            logger.error("发送嵌入静态资源的邮件时发生异常...", e);
        }
    }

}

编写测试用例

package com.songfayuan.springBoot.service;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

/**
 * 描述:邮件模板单元测试
 * @author songfayuan
 * 2017年12月13日下午2:39:52
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class MailServiceTest {

    @Autowired
    private MailService mailService;

    @Autowired
    private TemplateEngine templateEngine;

    //接受者账户
    private String to = "1414798079@qq.com"; 

    @Test
    public void testSimpleMail() throws Exception{
        String subject = "测试发送普通(文本)邮件";
        String content = "这是一封用于测试发送普通文本邮件的信息...";
        mailService.sendSimpleMail(to, subject, content);
    }

    @Test
    public void testHtmlMail() throws Exception{
        String subject = "测试发送html邮件";
        String content="<html>\n" +
                "<body>\n" +
                "    <h3>hello world ! 这是一封html邮件!</h3>\n" +
                "</body>\n" +
                "</html>";
        mailService.sendHtmlMail(to, subject, content);
    }

    @Test
    public void sendAttachmentMail() throws Exception{
        String subject = "测试发送带附件的邮件";
        String content = "这是一封用于测试发送带附件文件邮件的信息...";
        String filePath="D:\\Icon Manager.rar";
        mailService.sendAttachmentMail(to, subject, content, filePath);
    }

    @Test
    public void sendInlineResourceMail() throws Exception{
        String contentId = "demo01";
        String subject = "测试发送有图片的邮件";
        String content = "<html><body>这是一封用于测试发送有图片邮件的信息:<img src=\'cid:" + contentId + "\' ></body></html>";
        String resourcePath = "D:\\123456.png";
        mailService.sendInlineResourceMail(to, subject, content, resourcePath, contentId);
    }

    @Test 
    public void sendTemplateMail() throws Exception{
        String subject = "测试发送自定义模板邮件";
        Context context = new Context();
        context.setVariable("id", "demo002");
        String content = templateEngine.process("emailTemplate", context);
        mailService.sendHtmlMail(to, subject, content);
    }

}

SpringBoot整合mybatis及简单案例实现

添加依赖包

在pom.xml中添加mybatis的依赖包,如下:

        <!-- 整合mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- mysql jdbc驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency> 

添加相关配置

在application.properties添加如下配置:

# mybatis配置
mybatis.type-aliases-package=com.songfayuan.springBoot.entity
# mybatis设置自动驼峰命名转换
mybatis.configuration.mapUnderscoreToCamelCase=true
# mysql配置
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/spring_boot?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = 123456

在启动类Application中添加对包的扫描配置@MapperScan如下:

@SpringBootApplication
@MapperScan("com.songfayuan.springBoot.dao")
public class Application {

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

创建数据库

新建数据库spring_boot,并创建user表,字段名称如下:

id  int 11  0   0   -1  0   0   0       0                   -1  0
user_name   varchar 50  0   -1  0   0   0   0       0   用户名 utf8    utf8_general_ci     0   0
pass_word   varchar 255 0   -1  0   0   0   0       0   用户密码    utf8    utf8_general_ci     0   0
sex int 11  0   -1  0   0   0   0       0   性别(0 男 ,1女)             0   0
age int 11  0   -1  0   0   0   0       0   年龄              0   0
phone   varchar 50  0   -1  0   0   0   0       0   电话号码    utf8    utf8_general_ci     0   0
email   varchar 50  0   -1  0   0   0   0       0   电子邮件    utf8    utf8_general_ci     0   0

创建数据库映射实体

在com.songfayuan.springBoot.entity下创建UserEntity实体类,如下:

package com.songfayuan.springBoot.entity;

import java.io.Serializable;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月13日下午4:57:46
 */
public class UserEntity implements Serializable {

    private static final long serialVersionUID = 505461756494370991L;

    private Integer id;

    private String userName;

    private String passWord;

    private Integer age;

    private Integer sex;

    private String phone;

    private String email;

    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 getPassWord() {
        return passWord;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

}

创建dao接口

在com.songfayuan.springBoot.dao下创建UserDao接口,且通过注解方式实现对数据库的增删改查操作,具体代码如下:

package com.songfayuan.springBoot.dao;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.songfayuan.springBoot.entity.UserEntity;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月13日下午5:11:36
 */
public interface UserDao {

    /**
     * 描述:查询所有用户列表(不分页)
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:40:58
     */
    @Select("select * from user")
    public List<UserEntity> findUserList();

    /**
     * 描述:根据id获取一条用户数据
     * @param userId
     * @return
     * @author songfayuan
     * 2017年12月13日下午6:11:57
     */
    @Select("select * from user where id = #{userId}")
    public UserEntity findUserById(Integer userId);

    /**
     * 描述:添加用户
     * @param user
     * @author songfayuan
     * 2017年12月13日下午6:12:25
     */
    @Insert("insert into user(user_name, pass_word, sex, age, phone, email) values(#{userName}, #{passWord}, #{sex}, #{age}, #{phone}, #{email})")
    public void saveUser(UserEntity user);

    /**
     * 描述:根据id更新用户数据
     * @param user
     * @author songfayuan
     * 2017年12月13日下午6:20:15
     */
    @Update("update user set user_name=#{userName}, pass_word=#{passWord}, sex=#{sex}, age=#{age}, phone=#{phone}, email=#{email} where id = #{id}")
    public void updateUser(UserEntity user);

    @Delete("delete from user where id = #{userId}")
    public void deleteUser(Integer userId);

}

创建service接口和其实现类

在com.songfayuan.springBoot.service下创建Service接口,在com.songfayuan.springBoot.service.impl下创建Serviceimpl实现类:

UserService

package com.songfayuan.springBoot.service;

import java.util.List;

import com.songfayuan.springBoot.entity.UserEntity;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月13日下午5:08:58
 */
public interface UserService {

    /**
     * 描述:查询所有用户列表(不分页)
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:40:32
     */
    public List<UserEntity> findUserList();

    /**
     * 描述:根据id获取一条用户数据
     * @param userId
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:55:04
     */
    public UserEntity findUserById(Integer userId);

    /**
     * 描述:添加用户
     * @param user
     * @author songfayuan
     * 2017年12月13日下午6:12:16
     */
    public void saveUser(UserEntity user);

    /**
     * 描述:根据id更新用户数据
     * @param user
     * @author songfayuan
     * 2017年12月13日下午6:20:07
     */
    public void updateUser(UserEntity user);

    public void deleteUser(Integer userId);

}

UserServiceImpl

package com.songfayuan.springBoot.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.songfayuan.springBoot.dao.UserDao;
import com.songfayuan.springBoot.entity.UserEntity;
import com.songfayuan.springBoot.service.UserService;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月13日下午5:09:45
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<UserEntity> findUserList() {
        return this.userDao.findUserList();
    }

    @Override
    public UserEntity findUserById(Integer userId) {
        return this.userDao.findUserById(userId);
    }

    @Override
    public void saveUser(UserEntity user) {
        this.userDao.saveUser(user);
    }

    @Override
    public void updateUser(UserEntity user) {
        this.userDao.updateUser(user);
    }

    @Override
    public void deleteUser(Integer userId) {
        this.userDao.deleteUser(userId);
    }

}

创建Controller

在com.songfayuan.springBoot.controller下创建UserController:

package com.songfayuan.springBoot.controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.songfayuan.springBoot.entity.UserEntity;
import com.songfayuan.springBoot.service.UserService;
import com.songfayuan.springBoot.utils.Response;

/**
 * 描述:用户
 * @author songfayuan
 * 2017年12月13日下午5:05:47
 */
@RestController
@RequestMapping("/user")
public class UserController {

    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    /**
     * 描述:查询所有用户列表(不分页)
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:40:01
     */
    @RequestMapping("findUserList")
    public Response findUserList(){
        List<UserEntity> list =  this.userService.findUserList();
        return Response.success(list);
    }

    /**
     * 描述:根据id获取一条用户数据
     * @param userId
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:54:41
     */
    @RequestMapping("findUserById")
    public Response findUserById(Integer userId){
        UserEntity user = this.userService.findUserById(userId);
        return Response.success(user);
    }

    /**
     * 描述:添加用户
     * @param user
     * @return
     * @author songfayuan
     * 2017年12月13日下午6:12:05
     */
    @RequestMapping("addUser")
    public Response saveUser(UserEntity user){
        this.userService.saveUser(user);
        return Response.successResponse("添加成功");
    }

    /**
     * 描述:根据id更新用户数据
     * @param user
     * @return
     * @author songfayuan
     * 2017年12月13日下午6:19:52
     */
    @RequestMapping("updateUser")
    public Response updateUser(UserEntity user){
        this.userService.updateUser(user);
        return Response.successResponse("修改成功");
    }

    @RequestMapping("deleteUserById")
    public Response deleteUser(Integer userId){
        this.userService.deleteUser(userId);
        return Response.successResponse("删除成功");
    }

}

Controller中用到的Response为自己封装,具体代码如下:

package com.songfayuan.springBoot.utils;

public class Response {
    protected int code;
    protected String msg;
    protected Object data;

    private static final int SUCCESS_CODE = 200;
    private static final String SUCCESS_MSG = "success";
    private static final int ERROR_CODE = 500;
    private static final String ERROR_MSG = "服务器内部异常,请联系技术人员!";// 将error改成了内容信息

    public static Response success() {
        Response resp = new Response();
        resp.code = (SUCCESS_CODE);
        resp.msg = (SUCCESS_MSG);
        return resp;
    }

    public static Response successResponse(String msg) {
        Response resp = new Response();
        resp.code = SUCCESS_CODE;
        resp.msg = msg;
        return resp;
    }

    public static Response error() {
        Response resp = new Response();
        resp.code = (ERROR_CODE);
        resp.msg = (ERROR_MSG);
        return resp;
    }

    public static Response errorResponse(String msg) {
        Response resp = new Response();
        resp.code = ERROR_CODE;
        resp.msg = msg;
        return resp;
    }

    public static Response response(int code, String msg) {
        Response resp = new Response();
        resp.code = (code);
        resp.msg = (msg);
        return resp;
    }

    public static Response response(int code, String msg, Object data) {
        Response resp = new Response();
        resp.code = (code);
        resp.msg = (msg);
        resp.data = data;
        return resp;
    }

    public static Response success(Object data) {
        Response resp = new Response();
        resp.code = (SUCCESS_CODE);
        resp.msg = (SUCCESS_MSG);
        resp.data = data;
        return resp;
    }

    public static Response error(Object data) {
        Response resp = new Response();
        resp.code = (ERROR_CODE);
        resp.msg = (ERROR_MSG);
        resp.data = data;
        return resp;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

}

至此,我们成功的将springboot和mybatis整合在一起,并且实现了简单的增删改查。

自定义分页查询

自定义分页工具类:
Page

package com.songfayuan.springBoot.utils;

import java.util.List;

/**
 * 描述:分页工具
 * @author songfayuan
 * 2017年12月13日下午9:11:45
 * @param <T>
 */
public class Page<T> {
    List<T> data;
    Integer total;
    Integer start;
    Integer pageSize = 10;
    Integer resultCount;

    public static final int DEFAULE_PAGESIZE = 10;

    public Page(Integer start, Integer pageSize, Integer resultCount) {
        super();
        this.total = resultCount / pageSize + (resultCount % pageSize > 0 ? 1 : 0);
        this.start = start;
        this.pageSize = pageSize;
        this.resultCount = resultCount;
    }

    public Page() {
        super();
    }

    public Integer getTotal() {
        return total;
    }

    public void setTotal(Integer total) {
        this.total = total;
    }

    public List<T> getData() {
        return data;
    }

    public void setData(List<T> data) {
        this.data = data;
    }

    public Integer getStart() {
        return start;
    }

    public void setStart(Integer start) {
        this.start = start;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public Integer getResultCount() {
        return resultCount;
    }

    public void setResultCount(Integer resultCount) {
        this.resultCount = resultCount;
    }

}

在UserController中加入如下代码:

   /**
     * 描述:分页查询用户列表
     * @param page
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月13日下午9:25:11
     */
    @RequestMapping("/findUserListByPage")
    public Response findUserListByPage(Integer page, Integer pageSize){
        return this.userService.findUserListByPage(page, pageSize);
    }

在UserService接口中添加如下代码:

   /**
     * 描述:分页查询用户列表
     * @param page
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月13日下午9:25:40
     */
    public Response findUserListByPage(Integer page, Integer pageSize);

在UserServiceImpl实现类中添加如下代码:

    @Override
    public Response findUserListByPage(Integer page, Integer pageSize) {
        Integer offset = page > 0 ? page * pageSize : 0;
        List<UserEntity> list = this.userDao.findUserListByPage(offset, pageSize);
        Integer rows = this.userDao.findRows();
        Page<UserEntity> pagelist = new Page<>(page, pageSize, rows);
        pagelist.setData(list);
        return Response.success(pagelist);
    }

在UserDao接口中添加如下代码:

    /**
     * 描述:分页查询用户列表
     * @param offset
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月13日下午9:25:55
     */
    @Select("select * from user order by id limit #{offset},#{pageSize}")
    public List<UserEntity> findUserListByPage(@Param("offset") Integer offset, @Param("pageSize") Integer pageSize);

    /**
     * 描述:查询用户数量
     * @return
     * @author songfayuan
     * 2017年12月13日下午9:26:03
     */
    @Select("select count(id) from user")
    public Integer findRows();

至此,分页查询功能搞定。

SpringBoot整合AOP(案例:使用 AOP 切面的方式记录 web 请求日志)

添加依赖

pom.xml

        <!-- aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!-- UserAgent工具类:https://mvnrepository.com/artifact/nl.bitwalker/UserAgentUtils -->
        <dependency>
            <groupId>nl.bitwalker</groupId>
            <artifactId>UserAgentUtils</artifactId>
            <version>1.2.4</version>
        </dependency>

编辑切面

新建数据库log表:

id  int 11  0   0   -1  0   0   0       0   日志id                -1  0
create_time timestamp   0   0   -1  0   0   0   0   CURRENT_TIMESTAMP   0   日志产生时间              0   0
log_type    int 11  0   -1  0   0   0   0       0   日志类型(1601信息,1602异常)             0   0
content text    0   0   -1  0   0   0   0       0   日志内容    utf8    utf8_general_ci     0   0
user_id int 11  0   -1  0   0   0   0       0   操作人员                0   0

编辑切面

在com.songfayuan.springBoot.aspectj下编辑切面,按自己的需求造出自己的代码:

package com.songfayuan.springBoot.aspectj;

import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSONObject;
import com.songfayuan.springBoot.entity.LogEntity;
import com.songfayuan.springBoot.service.LogService;

import nl.bitwalker.useragentutils.UserAgent;



/**
 * 描述:【声明切面】记录请求日志
 * @author songfayuan
 * 2017年12月14日上午11:26:24
 */
@Aspect
@Service
public class RequestLogAspect {

    private static final String START_TIME = "start_request_time";

    private static final Logger logger = LoggerFactory.getLogger(RequestLogAspect.class);

    //注入Service用于把日志保存数据库
    @Autowired
    private LogService logService;

    //声明controller层切入点
    @Pointcut("execution(* com.songfayuan.springBoot.controller.*.*(..))")
    public void controllerAspect(){
    }

    //声明service层切入点
    @Pointcut("execution(* com.songfayuan.springBoot.service.*.*(..)) && !execution(* com.songfayuan.springBoot.service.LogService.*(..) )")
    public void serviceAspect(){
    }

    /**
     * 描述:声明前置通知-用于拦截Controller请求日志
     * @param joinPoint
     * @author songfayuan
     * 2017年12月14日下午1:31:12
     */
    @Before("controllerAspect()")
    public void doBefore(JoinPoint joinPoint){
        HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
        try {
            logger.info("【请求 URL】:{}", request.getRequestURL());
            logger.info("【请求 IP】:{}", request.getRemoteAddr());
            logger.info("【请求类名】:{},【请求方法名】:{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
            Map parameterMap = request.getParameterMap();
            logger.info("【请求参数】:{},", JSONObject.toJSONString(parameterMap));
            Long start = System.currentTimeMillis();
            request.setAttribute(START_TIME, start);
            // *========数据库日志=========*//
            LogEntity log = new LogEntity();
            log.setContent("【请求类名】:"+joinPoint.getSignature().getDeclaringTypeName()+",【请求方法名】:"+joinPoint.getSignature().getName()); //此处记录请求类名和方法名,用户还可以自己自定义注解,记录每个方法的描述
            log.setLogType(1061); //日志类型(1601信息,1602异常)
            log.setUserId(0); //用户id-若完成登录功能后在此获取用户的id
            // *========保存数据库=========*//
            logger.info(".............Controller操作日志保存开始.............");
            this.logService.save(log);
            logger.info(".............Controller操作日志保存结束.............");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("==前置通知异常==");
            logger.error("【异常信息】:{}", e.getMessage());
        }
    }

    /**
     * 描述:声明环绕通知-用于返回请求数据
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     * @author songfayuan
     * 2017年12月14日下午1:31:51
     */
    @Around("controllerAspect()")
    public Object arroundLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        Object result = proceedingJoinPoint.proceed();
        logger.info("【返回值】:{}", JSONObject.toJSONString(result));
        return result;
    }

    /**
     * 描述:声明后置通知-用于记录请求时长
     * @param joinPoint
     * @author songfayuan
     * 2017年12月14日下午1:32:31
     */
    @AfterReturning("controllerAspect()")
    public void afterReturning(JoinPoint joinPoint){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Long start = (Long) request.getAttribute(START_TIME);
        Long end = System.currentTimeMillis();
        try {
            logger.info("【请求耗时】:{}毫秒", end - start);
            String header = request.getHeader("User-Agent");
            UserAgent userAgent = UserAgent.parseUserAgentString(header);
            logger.info("【浏览器类型】:{},【操作系统】:{},【原始User-Agent】:{}", userAgent.getBrowser().toString(), userAgent.getOperatingSystem().toString(), header);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("==后置通知异常==");
            logger.error("【异常信息】:{}", e.getMessage());
        }
    }

    /**
     * 描述:异常通知-用户拦截service层操作异常
     * @param joinPoint
     * @param e
     * @author songfayuan
     * 2017年12月14日下午2:01:12
     */
    @AfterThrowing(pointcut = "serviceAspect()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Throwable e){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        BigInteger time = new BigInteger(System.currentTimeMillis()+"");
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String timestr = df.format(new Date(new Long(time+"")));
        try {
            logger.info("【请求时间】:" + timestr);
            logger.info("【异常代码】:" + e.getClass().getName());
            logger.info("【异常信息】:" + e.getMessage());
            logger.info("【异常方法】:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
            Map parameterMap = request.getParameterMap();
            logger.info("【请求参数】:{},", JSONObject.toJSONString(parameterMap));
            // *========数据库日志=========*//
            LogEntity log = new LogEntity();
            log.setContent("【异常代码】:" + e.getClass().getName()+",【异常信息】:" + e.getMessage()+",【异常方法】:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()")+"。");
            log.setLogType(1061); //日志类型(1601信息,1602异常)
            log.setUserId(0); //用户id-若完成登录功能后在此获取用户的id
            // *========保存数据库=========*//
            logger.info(".............Controller操作日志保存开始.............");
            this.logService.save(log);
            logger.info(".............Controller操作日志保存结束.............");            
        } catch (Exception exception) {
            exception.printStackTrace();
            logger.error("==异常通知异常==");
            logger.error("【异常信息】:{}", exception.getMessage());
        }
    }

}

读取用户操作日志

创建LogController类

package com.songfayuan.springBoot.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.songfayuan.springBoot.entity.LogEntity;
import com.songfayuan.springBoot.entity.UserEntity;
import com.songfayuan.springBoot.service.LogService;
import com.songfayuan.springBoot.utils.Response;

/**
 * 描述:用户请求日志
 * @author songfayuan
 * 2017年12月14日下午3:23:18
 */
@RestController
@RequestMapping("/log")
public class LogController {

    Logger logger = LoggerFactory.getLogger(LogController.class);

    @Autowired
    private LogService logService;

    /**
     * 描述:分页查询用户请求日志
     * @param page
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:27:41
     */
    @RequestMapping("/findLogListByPage")
    public Response findLogListByPage(Integer page, Integer pageSize){
        return this.logService.findLogListByPage(page, pageSize);
    }

    /**
     * 描述:查看日志详情
     * @param id
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:33:00
     */
    @RequestMapping("/findLogById")
    public Response findLogById(Integer id){
        LogEntity logEntity = this.logService.findLogById(id);
        return Response.success(logEntity);
    }

}

创建LogService接口

package com.songfayuan.springBoot.service;

import com.songfayuan.springBoot.entity.LogEntity;
import com.songfayuan.springBoot.utils.Response;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月14日下午2:49:42
 */
public interface LogService {

    /**
     * 描述:保存日志记录
     * @param log
     * @author songfayuan
     * 2017年12月14日下午3:10:34
     */
    public void save(LogEntity log);

    /**
     * 描述:分页查询用户请求日志
     * @param page
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:28:02
     */
    public Response findLogListByPage(Integer page, Integer pageSize);

    /**
     * 描述:查看日志详情
     * @param id
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:33:16
     */
    public LogEntity findLogById(Integer id);

}

创建LogServiceImpl类

package com.songfayuan.springBoot.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.songfayuan.springBoot.dao.LogDao;
import com.songfayuan.springBoot.entity.LogEntity;
import com.songfayuan.springBoot.service.LogService;
import com.songfayuan.springBoot.utils.Page;
import com.songfayuan.springBoot.utils.Response;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月14日下午2:50:02
 */
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;

    @Override
    public void save(LogEntity log) {
        this.logDao.save(log);
    }

    @Override
    public Response findLogListByPage(Integer page, Integer pageSize) {
        Integer offset = page > 0 ? page * pageSize : 0;
        List<LogEntity> list = this.logDao.findLogListByPage(offset, pageSize);
        Integer rows = this.logDao.findRows();
        Page<LogEntity> pagelist = new Page<>(page, pageSize, rows);
        pagelist.setData(list);
        return Response.success(pagelist);
    }

    @Override
    public LogEntity findLogById(Integer id) {
        return this.logDao.findLogById(id);
    }

}

创建LogDao接口

package com.songfayuan.springBoot.dao;

import java.util.List;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import com.songfayuan.springBoot.entity.LogEntity;
import com.songfayuan.springBoot.entity.UserEntity;

/**
 * 描述:
 * @author songfayuan
 * 2017年12月14日下午2:50:28
 */
public interface LogDao {

    /**
     * 描述:保存日志记录
     * @param log
     * @author songfayuan
     * 2017年12月14日下午3:12:07
     */
    @Insert("insert into log(log_type, content, user_id) values(#{logType}, #{content}, #{userId})")
    public void save(LogEntity log);

    /**
     * 描述:分页查询用户请求日志
     * @param offset
     * @param pageSize
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:29:31
     */
    @Select("select * from log order by id desc limit #{offset},#{pageSize}")
    public List<LogEntity> findLogListByPage(@Param("offset") Integer offset, @Param("pageSize") Integer pageSize);

    /**
     * 描述:查询日志条数
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:30:54
     */
    @Select("select count(id) from log")
    public Integer findRows();

    /**
     * 描述:查看日志详情
     * @param id
     * @return
     * @author songfayuan
     * 2017年12月14日下午3:33:55
     */
    @Select("select * from log where id = #{id}")
    public LogEntity findLogById(Integer id);

}

时间格式配置

在application.properties中添加如下配置:

#时间戳统一转换
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

自定义注解

声明注解

自定义注解为方法添加方法描述并记录进操作日志,首先在com.songfayuan.springBoot.annotation下创建注解类ControllerMethodDescription,代码如下:

package com.songfayuan.springBoot.annotation;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Documented
@Retention(RUNTIME)
@Target(METHOD)
/**
 * 描述:自定义注解-用于添加Controller方法描述
 * @author songfayuan
 * 2017年12月15日上午10:36:37
 */
public @interface ControllerMethodDescription {

    /**
     * 描述:方法描述
     * @return
     * @author songfayuan
     * 2017年12月15日上午10:40:56
     */
    String description() default "controller method default description...";

}

接下来在之前的切面RequestLogAspect中添加如下方法:

    /**
     * 描述:获取注解中对方法的描述信息-用于Controller层注解
     * @param joinPoint
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @author songfayuan
     * 2017年12月15日上午11:36:55
     */
    public static String getControllerMethodDescription(JoinPoint joinPoint) throws NoSuchMethodException, SecurityException {
        //获取拦截的方法名
        Signature signature = joinPoint.getSignature();
        MethodSignature mSignature = null;
        if (!(signature instanceof MethodSignature)) {
            logger.error("ControllerMethodDescription注解只能用于方法");
            throw new IllegalArgumentException("ControllerMethodDescription注解只能用于方法");
        }
        mSignature = (MethodSignature) signature;
        Object target = joinPoint.getTarget();
        //获取拦截方法的参数
        Method method = target.getClass().getMethod(mSignature.getName(), mSignature.getParameterTypes());
        //获取操作业务的名称
        ControllerMethodDescription annotation = method.getAnnotation(ControllerMethodDescription.class);
        String description = null;
        if (annotation!=null) {
            description = annotation.description();
        }
        return description;
    }

再修改下RequestLogAspect中的前置通知代码,具体请查看源码。

使用注解

在Controller中的接口方法前加上我们刚自定义好的注解,添加上方法描述即可,如:

    /**
     * 描述:查询所有用户列表(不分页)
     * @return
     * @author songfayuan
     * 2017年12月13日下午5:40:01
     */
    @ControllerMethodDescription(description="查询所有用户列表(不分页)")   //自定义注解:用于拦截方法描述,若不用不写此注解即可
    @RequestMapping("/findUserList")
    public Response findUserList(){
        List<UserEntity> list =  this.userService.findUserList();
        return Response.success(list);
    }

===========【end】============


更多的功能正在编辑中…

更多功能正在更新中…..敬请期待!
点击这里给我发消息

示例代码-github

如果喜欢,请多多分享、多多Star

作者信息

打赏

分享不易,开心的话,可以请我喝杯咖啡哦O(∩_∩)O~

支付宝:

微信

展开阅读全文

没有更多推荐了,返回首页