Spring boot 小示例项目

包含拦截器、使用自定义的HQL和部署到外部tomcat

准备工作

需要在eclipse 使用STS插件，创建一个spring boot项目
需要使用的dependencies主要是：MySql、JDBC、JPA、Rest Repositories 和 Web
还需要另外加lombok的依赖

实体类

用户、用户发布的文章和msg数据实体（用来传给前端的，没有实际的表）

用户实体User.java

package slience.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Table(name="t_user")
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;
    private String name;
    private String pwd;
    private int age;
    
    public User(String name, String pwd, int age) {
        this.pwd = pwd;
        this.name = name;
        this.age = age;
    }
}

数据实体Msg.java

package slience.entity;


import org.springframework.stereotype.Component;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class Msg {
    private String message;
    private int code;
    private Object data;
    public void set(String message, int code, Object data) {
        this.message = message;
        this.code = code;
        this.data = data;
    }
}

文章实体Article.java

package slience.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;

@Data
@Entity
@Table(name="t_article")
@RequiredArgsConstructor
@NoArgsConstructor
public class Article {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;
    @NonNull
    private String title;
    @NonNull
    @ManyToOne
    private User user;
    @NonNull
    @Column(columnDefinition="varchar(9527) default '' comment '文章内容'")
    private String content;
    
    public Article(long id, String title, String content) {
        this.id = id;
        this.title = title;
        this.content = content;
    }
}

文章实体中使用通过使用@NonNull和@RequiredArgsConstructor来自动生成指定参数的构造函数，这样做如果在其他地方去取某些数据——被@NonNull标注的属性的内容为空的数据，可能会报错。

DAO层

通过创建继承了PagingAndSortingRepository的接口来实现基本的增删改查和分页，可以直接在接口声明自定义的数据查询方法
用户Repository

package slience.repository;

import org.springframework.data.repository.PagingAndSortingRepository;

import slience.entity.User;

public interface UserRepository extends PagingAndSortingRepository<User, Long> {
    //不必实现此方法，Spring会自动通过生成，前提是User实体中有Name属性
    public User findByName(String name);
}

文章Repository

package slience.repository;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

import slience.entity.Article;
import slience.entity.User;

public interface ArticleRepository extends PagingAndSortingRepository<Article, Long> {
    //使用自己的HQL语句，使用select new Article(id,title,content)来过滤Article实体中的User属性
    //这样做的时候Article实体必须要有接收(id,title,content)这三个参数的构造函数
    @Query("select new Article(id,title,content) from Article a where a.user=:user")
    public Page<Article> findByUser(@Param("user") User user, Pageable pageable);
}

Controller层

BaseController基本控制器，我比较喜欢把一些共用的东西放在BaseController中，实际开发中可以看项目需求酌情设置，controller中使用到的Code和TokenUtil都是一些静态的工具类，用以标识请求状态和生成token的，没啥用，你们自己替换或者直接去掉就好。

package slience.controller;

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

import slience.entity.Msg;
import slience.repository.ArticleRepository;
import slience.repository.UserRepository;

public class BaseController {
    @Autowired
    protected Msg msg;
    @Autowired
    protected UserRepository userRepository;
    @Autowired
    protected ArticleRepository articleRepository;
    
}

UserController.java

package slience.controller;

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

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.SessionAttribute;

import slience.entity.Msg;
import slience.entity.User;
import slience.util.Code;
import slience.util.TokenUtil;

@RestController
@RequestMapping(value="/user")
public class UserController extends BaseController {
    
    @RequestMapping(value="/register", method=RequestMethod.POST)
    public Object register(@RequestParam String name, @RequestParam String pwd, @RequestParam int age) {
        //验证用户名是否重复
        User user = userRepository.findByName(name);
        if(user != null) {
            msg.set("用户名重复", Code.ERROR, null);
        } else {
            user = new User(name, pwd, age);
            user = userRepository.save(user);
            String token = TokenUtil.create(user.getId()); 
            msg.set("注册成功", Code.SUCCESS, token);
        }
        return msg;
    }
    
    /**
     * 用户登录
     * @param name
     * @param Pwd
     * @return
     */
    @RequestMapping(value="/login", method=RequestMethod.POST)
    public Object login(@RequestParam String name, @RequestParam String pwd) {
        User user = userRepository.findByName(name);
        if(user != null) {
            if(user.getPwd().equals(pwd)) {
                //别把密码发到前端
                user.setPwd(null);
                
                Map<String , Object> result = new HashMap<>();
                result.put("token", TokenUtil.create(user.getId()));
                result.put("user", user);
                msg.set("登录成功", Code.SUCCESS, result);
            } else {
                msg.set("密码错误", Code.ERROR, null);
            }
        } else {
            msg.set("未找到此用户", Code.ERROR, null);
        }
        return msg;
    }
    /**
     * 修改用户信息
     * @param session
     * @param name
     * @return
     */
    @RequestMapping(value="/update", method=RequestMethod.POST)
    public Msg update(@SessionAttribute User user, @RequestParam(required=false) String name) {
        boolean isChange = false;
        if(name != null) {
            user.setName(name);
            isChange = true;
        }
        
        if(isChange) {
            user = userRepository.save(user);
            user.setPwd(null);
            msg.set("修改成功", Code.SUCCESS, user);
        } else {
            msg.set("没有要修改的数据", Code.ERROR, null);
        }
        return msg;
    }
    
    @RequestMapping(value="/test", method=RequestMethod.GET)
    public Object test() throws Exception {
        System.out.println("test");
        User user = userRepository.findOne((long) 1);
        msg.set("ok", Code.SUCCESS, user);
        return msg;
    }
}

ArticleController.java

package slience.controller;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.SessionAttribute;

import slience.entity.Article;
import slience.entity.Msg;
import slience.entity.User;
import slience.util.Code;

@RestController
@RequestMapping(value="/article")
public class ArticleController extends BaseController {
    /**
     * 创建文章
     * @param user
     * @param title
     * @param content
     * @return
     * @throws Exception
     */
    @RequestMapping(value="/create", method=RequestMethod.POST)
    public Msg create(@SessionAttribute User user, @RequestParam String title, @RequestParam String content) throws Exception {
        Article article = new Article(title, user, content);
        article = articleRepository.save(article);
        msg.set("创建成功", Code.SUCCESS, null);
        return msg;
    }
    /**
     * 更新文章
     * @param user
     * @param id
     * @param title
     * @param content
     * @return
     */
    @RequestMapping(value="/update", method=RequestMethod.POST)
    public Msg update(@SessionAttribute User user, @RequestParam long id,
            @RequestParam(required=false) String title, @RequestParam(required=false) String content) throws Exception {
        Article article = articleRepository.findOne(id);
        if(article != null) {
            if(article.getUser().getId() == user.getId()) {
                //是作者本人
                boolean isChange = false;
                if(title != null && !article.getTitle().equals(title)) {
                    article.setTitle(title);
                    isChange = true;
                } 
                if(content != null && !content.equals(article.getContent())) {
                    article.setContent(content);
                    isChange = true;
                }
                if(isChange) {
                    articleRepository.save(article);
                    msg.set("修改成功", Code.SUCCESS, null);
                } else {
                    msg.set("没有要修改的内容", Code.ERROR, null);
                }
            } else {
                msg.set("您不是本文的作者不能进行修改", Code.ERR_AUTH, null);
            }
        } else {
            msg.set("未找到此文章", Code.ERROR, null);
        }
        return msg;
    }
    
    @RequestMapping(value="/{id}", method=RequestMethod.POST)
    public Msg findByUser(@PathVariable("id") long userId, @RequestParam int page, @RequestParam int size) {
        User user = userRepository.findOne(userId);
        if(user != null) {
            Page<Article> articles = articleRepository.findByUser(user,new PageRequest(page, size, new Sort(Sort.Direction.DESC, "id")));
            msg.set("查询成功", Code.SUCCESS, articles);
        } else {
            msg.set("未找到此用户", Code.ERROR, null);
        }
        return msg;
    }
}

过滤器

此过滤器主要实现了将请求中的token转化成用户实体并捆绑到session中（弄到request会造成前后实体不同的原因，在update用户的时候发现的，因为update的时候也可以用Repository的save，如果是同一个是update，如果是新的就是save，我最初是在过滤器中拿到user实体放在request里的结果造成了每次update都是创建一个新的用户）

package slience.interceptor;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import slience.entity.Msg;
import slience.entity.User;
import slience.repository.UserRepository;
import slience.util.Code;
import slience.util.HttpTool;
import slience.util.TokenUtil;

/**
 * 权限拦截器
 * @author slience
 *
 */
public class AuthInterceptor implements HandlerInterceptor {

    @Autowired
    private Msg msg;
    @Autowired
    private UserRepository userRepository;
    
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("验证token");
        String token = request.getParameter("token");
        if(token != null) {
            long userId = TokenUtil.verify(token);
            if(userId > 0) {
                User user = userRepository.findOne(userId);
                if(user != null) {
                    request.getSession().setAttribute("user", user);
                    return true;
                } else {
                    msg.set("没有找到指定用户", Code.ERR_AUTH, null);
                }
            } else if(userId == 0) {
                msg.set("token超时，请重新登录", Code.ERR_AUTH, null);
            } else {
                msg.set("token有误", Code.ERR_AUTH, null);
            }
        } else {
            msg.set("请先登录", Code.ERR_AUTH, null);
        }
        HttpTool.jsonMsg(response, msg);
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
    }

}

项目配置

在这里主要是引入过滤器和防止跨域
WebConfiguration.java

package slience.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import slience.interceptor.AuthInterceptor;

@Configuration
public class WebConfiguration extends WebMvcConfigurerAdapter {
    @Bean
    public AuthInterceptor authInterceptor() {
        return new AuthInterceptor(); 
    }
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor()).addPathPatterns("/**")
        //不过滤的路径
        .excludePathPatterns("/user/register", "/user/login", "/user/test");
    }
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        //防止跨域
        registry.addMapping("/**").allowedOrigins("*").allowedHeaders("*").allowedMethods("*");
    }
}

执行类Application.java

package slience;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringMvcTest2Application extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringMvcTest2Application.class);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(SpringMvcTest2Application.class, args);
    }
}

这样应该就可以用嵌入式的tomcat运行项目了，接下来我们要使用外部的tomcat来运行，在pom.xml中修改packaging从jar改为war，在dependencies中添加（2017-10-18日更新：其实不加也可以）

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

完整的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.momo.slience</groupId>
    <artifactId>test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-mvc-test-2</name>
    <description>自己测试</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </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>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.6</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.35</version>
        </dependency>

    </dependencies>

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


</project>

我们可以再src/main/webapp文件下创建一个index.html弄一个简单的主页
接下来我们找到Java Resources下的src/main/resouces文件夹中的application.properties中添加如下语句

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/spring-boot-test
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.hibernate.ddl-auto=create-drop

分别指定驱动类、链接地址、mysql用户名、用户密码和每次启动都会重新创建一次数据库（酌情添加）
弄好完整的项目目录是这样的


之后我们对着项目右键->Run as ->Run On Server，第一次好像要自己选运行的服务器组件（如果是要用Spring boot内置的tomcat就选Run as ->Spring Boot App）
出现刚刚的主页并且控制台没有什么奇怪的东西就说明配置成功了

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,185评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,445评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,684评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,564评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,681评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,874评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,025评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,761评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,217评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,545评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,694评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,351评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,988评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,778评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,007评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,427评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,580评论 2赞 349

推荐阅读更多精彩内容

  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,778评论 6赞 342
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,633评论 18赞 139
  • 问秋
    八月未央，转瞬间秋的脚步悄然走近。思绪还驻在一个盛夏的热烈里，那个明媚的季节却即将到来，那些清朗高远的日子，丰盈着...
    华枝春满5339阅读 335评论 1赞 4
  • 情人没有节
    “愿得一人心，白首不相离。” 不知道是不是快到情人节的原因，这两天一直翻来翻去的默念这句话。 得心，愿白首....
    two姑娘阅读 309评论 0赞 0
  • 啦啦啦啦啦
    啦啦啦啦
    光影城市阅读 75评论 0赞 0