springBoot构建并返回一个json对象

引入web依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>${spring.version}</version>
</dependency>

web间接依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>${jackson.version}</version>
</dependency>
 
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.version</version>
</dependency>
 
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>${jackson.version</version>
</dependency>

2 Controller类型

方式一：
@RestController注解类

方式二：
@Controller注解类
@ResponseBody注解方法

3 Getter与Setter方法

作为Controller返回值的对象类，必须拥有相应字段的Getter和Setter方法。
否则，无法自动转化为JSON格式字符串，导致异常。

jackson的基本演绎法

//忽略显示
    @JsonIgnore
    private String password;
    private Integer age;
    //格式化
    @JsonFormat(pattern="yyyy-MM-dd hh:mm:ss a", locale="zh", timezone="GMT+8")
    private Date birthday;
    //为null不显示
    @JsonInclude(Include.NON_NULL)
    private String desc;

springBoot开发环境的热部署

方式一：采用devtools进行热部署

1：引入依赖

<!-- 热部署 -->
<!-- devtools可以实现页面热部署（即页面修改后会立即生效，
这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现）
模板页面也可以实现热部署 -->
<!-- 实现类文件热部署（类文件修改后不会立即生效），实现对属性文件的热部署。 -->
<!-- 即devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），
            注意：因为其采用的虚拟机机制，该项重启是很快的 -->
<!-- （1）base classloader （Base类加载器）：加载不改变的Class，例如：第三方提供的jar包。 -->
<!-- （2）restart classloader（Restart类加载器）：加载正在开发的Class。 -->
<!-- 为什么重启很快，因为重启的时候只是加载了在开发的Class，没有重新加载第三方的jar包。 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <!-- optional=true, 依赖不会传递, 该项目依赖devtools; 
                之后依赖boot项目的项目如果想要使用devtools, 需要重新引入 -->
            <optional>true</optional>
        </dependency>

#关闭缓存可以及时刷新
#spring.freemarker.cache=false
#spring.thymeleaf.cache=true

#热部署生效
spring.devtools.restart.enabled=true
#生效的位置设定
spring.devtools.restart.additional-paths=src/main/java

# 为mybatis的设置，生产环境可以删除
restart.include.mapper=/mapper-[\\w-\\.]+jar
restart.include.pagehelper=/pagehelper-[\\w-\\.]+jar
#排除那个文件不需要的restart
#spring.devtools.restart.exclude=static/**,public/**
#classpath目录下的WEB-INF文件夹内容修改不重启
#spring.devtools.restart.exclude=WEB-INF/**

springBoot资源文件属性的配置

添加依赖

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>  

定义properties文件

com.imooc.opensource.name=maomao
com.imooc.opensource.website=www.mao.com
com.imooc.opensource.language=java

定义的配置文件实体类

@Configuration
@ConfigurationProperties(prefix="com.imooc.opensource")
@PropertySource(value="classpath:resource.properties")
public class Resource {
    private String name;
    private String website;
    private String language;
get....
set....
}

springBoot配置server

设置端口号
#server.port=8088
设置项目路径，一般正式发布的时候不配置
#server.context-path=/IMooc
设置错误页面url
#server.error.path=/error
设置session超时时间，默认为30
server.session-timeout=60
设置能访问的主机名，特殊情况下配置
#server.address=192.168.1.2
设置tomcat的最大线程数量，默认为200
#server.tomcat.max-threads=250
设置Tomcat的url编码格式
server.tomcat.uri-encoding=UTF-8
存放tomcat的日志，dump等文件的临时文件夹，默认为系统的tmp文件夹
#server.tomcat.basedir=H:/springboot-tomcat-tmp
打开tomcat的Access日志，并可以设置日志格式的方法
#server.tomcat.access-log-enabled=true
#server.tomcat.access-log-pattern
accesslog目录，默认在basedir/logs
#server.tomcat.accesslog.directory=
日志文件目录
#logging.path=H:/springboot-tomcat-tmp
日志文件名称，默认为spring.log
#logging.file=myapp.log 

springBoot整合模板引擎（很多渲染来之与客户端，比jsp要快，好）

1：freemarker
2：thymeleaf

引入freemarker的依赖

<!-- 引入 freemarker 模板依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
或       
        <!-- 引入 thymeleaf 模板依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

配置freemarker的属性

freemarker静态资源的配置
设定ftl的文件路径
spring.freemarker.template-loader-path=classpath:/templates
关闭缓存，即时刷新，上线生产环境需要改为true
spring.freemarker.cache=false
spring.freemarker.charset=UTF-8
spring.freemarker.check-template-location=true
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=true
spring.freemarker.expose-session-attributes=true
spring.freemarker.request-context-attribute=request
spring.freemarker.suffix=.ftl

@Controller
@RequestMapping("ftl")
public class FreemarkerController {

    @Autowired
    private Resource resource;
    
    @RequestMapping("/index")
    public String index(ModelMap map) {
        map.addAttribute("resource", resource);
        return "freemarker/index";
    }
    
    @RequestMapping("center")
    public String center() {
        return "freemarker/center/center";
    }

}

thymeleaf的整合

配置
# thymeleaf 静态资源配置
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html
# 关闭缓存，即时刷新，上线生产环境需要改成true
spring.thymeleaf.cache=false

@Controller
@RequestMapping("th")
public class ThymeleafController {

    @RequestMapping("/index")
    public String index(ModelMap map) {
        map.addAttribute("name", "thymeleaf-imooc");
        return "thymeleaf/index";
    }
    
    @RequestMapping("center")
    public String center() {
        return "thymeleaf/center/center";
    }
    
    @RequestMapping("test")
    public String test(ModelMap map) {
        
        User u = new User();
        u.setName("superadmin");
        u.setAge(10);
        u.setPassword("123465");
        u.setBirthday(new Date());
        u.setDesc("<font color='green'><b>hello imooc</b></font>");
        
        map.addAttribute("user", u);
        
        User u1 = new User();
        u1.setAge(19);
        u1.setName("imooc");
        u1.setPassword("123456");
        u1.setBirthday(new Date());
        
        User u2 = new User();
        u2.setAge(17);
        u2.setName("LeeCX");
        u2.setPassword("123456");
        u2.setBirthday(new Date());
        
        List<User> userList = new ArrayList<>();
        userList.add(u);
        userList.add(u1);
        userList.add(u2);
        
        map.addAttribute("userList", userList);
        
        return "thymeleaf/test";
    }
    
    @PostMapping("postform")
    public String postform(User u) {
        
        System.out.println("姓名：" + u.getName());
        System.out.println("年龄：" + u.getAge());
        
        return "redirect:/th/test";
    }
    
    @RequestMapping("showerror")
    public String showerror(User u) {
        
        int a = 1 / 0;
        
        return "redirect:/th/test";
    }
}

thymeleaf常用标签的使用方法

1：基本使用方式
2：对象引用方式
3：时间类型转换
4：th：text和th：Utext（utext会把里面的标签转化为属性）
5：url
6：引入静态资源文件js/css
7：条件判断：th：if
8：th：unless与th：if
9：循环：th：each
10：th:switch与th：case

用户姓名：<input th:id="${user.name}" th:name="${user.name}" th:value="${user.name}"/>

    用户年龄：<input th:value="${user.age}"/>
    
    用户生日：<input th:value="${user.birthday}"/>
    //格式化日期
    用户生日：<input th:value="${#dates.format(user.birthday, 'yyyy-MM-dd')}"/>
另一种方式
<div th:object="${user}">
    用户姓名：<input th:id="*{name}" th:name="*{name}" th:value="*{name}"/>
    <br/>
    用户年龄：<input th:value="*{age}"/>
    <br/>
    用户生日：<input th:value="*{#dates.format(birthday, 'yyyy-MM-dd hh:mm:ss')}"/>
    <br/>
</div>

URL:
<a href="" th:href="@{http://www.imooc.com}">网站地址</a>

要引用静态资源文件，要设置properties

设置静态资源文件路径js，css

spring.mvc.static-path-pattern=/static/**

引用静态资源文件

<script th:src="@{/static/js/test.js}"></script>

form表单
<form th:action="@{/th/postform}" th:object="${user}" method="post" th:method="post">
    <input type="text" th:field="*{name}"/>
    <input type="text" th:field="*{age}"/>
    <input type="submit"/>
</form>

if
<div th:if="${user.age} == 18">十八岁的天空</div>
<div th:if="${user.age} gt 18">你老了</div>
<div th:if="${user.age} lt 18">你很年轻</div>

 <option >选择框</option>
     <option th:selected="${user.name eq 'lee'}">lee</option>
     <option th:selected="${user.name eq 'imooc'}">imooc</option>
     <option th:selected="${user.name eq 'LeeCX'}">LeeCX</option>

循环
<tr th:each="person:${userList}">
        <td th:text="${person.name}"></td>
        <td th:text="${person.age}"></td>
        <td th:text="${person.age gt 18} ? 你老了 : 你很年轻">18岁</td>
        <td th:text="${#dates.format(user.birthday, 'yyyy-MM-dd hh:mm:ss')}"></td>
    </tr>

配置i18n资源文件，供thymeleaf读取

spring.messages.basename=i18n/messages
spring.messages.cache-seconds=3600
spring.messages.encoding=UTF-8

i18n/messages的properties文件
roles.manager=manager
roles.superadmin=superadmin

<div th:switch="${user.name}">
  <p th:case="'lee'">lee</p>
  <p th:case="#{roles.manager}">普通管理员</p>
  <p th:case="#{roles.superadmin}">超级管理员</p>
  <p th:case="*">其他用户</p>
</div>

springBoot全局异常捕获

1 页面跳转形式
2 ajax形式
3 统一返回异常形式

创建异常处理类，返回到error页面
@ControllerAdvice
public class IMoocExceptionHandler {

    public static final String IMOOC_ERROR_VIEW = "error";

    @ExceptionHandler(value = Exception.class)
    public Object errorHandler(HttpServletRequest reqest, 
            HttpServletResponse response, Exception e) throws Exception {
        
        e.printStackTrace();
    
        ModelAndView mav = new ModelAndView();
        mav.addObject("exception", e);
        mav.addObject("url", reqest.getRequestURL());
        mav.setViewName(IMOOC_ERROR_VIEW);
        return mav;
    }
}

ajax异常请求处理

@RestControllerAdvice
public class IMoocAjaxExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    public IMoocJSONResult defaultErrorHandler(HttpServletRequest req, 
            Exception e) throws Exception {

        e.printStackTrace();
        return IMoocJSONResult.errorException(e.getMessage());
    }
}

统一异常处理加一个判断

@ControllerAdvice
public class IMoocExceptionHandler {

    public static final String IMOOC_ERROR_VIEW = "error";
    @ExceptionHandler(value = Exception.class)
    public Object errorHandler(HttpServletRequest reqest, 
            HttpServletResponse response, Exception e) throws Exception {
        
        e.printStackTrace();
        
        if (isAjax(reqest)) {
            return IMoocJSONResult.errorException(e.getMessage());
        } else {
            ModelAndView mav = new ModelAndView();
            mav.addObject("exception", e);
            mav.addObject("url", reqest.getRequestURL());
            mav.setViewName(IMOOC_ERROR_VIEW);
            return mav;
        }
    }
    
    /**
     * 
     * @Title: IMoocExceptionHandler.java
     * @Package com.imooc.exception
     * @Description: 判断是否是ajax请求
     * Copyright: Copyright (c) 2017
     * Company:FURUIBOKE.SCIENCE.AND.TECHNOLOGY
     * 
     * @author leechenxiang
     * @date 2017年12月3日 下午1:40:39
     * @version V1.0
     */
    public static boolean isAjax(HttpServletRequest httpRequest){
        return  (httpRequest.getHeader("X-Requested-With") != null  
                    && "XMLHttpRequest"
                        .equals( httpRequest.getHeader("X-Requested-With").toString()) );
    }
}

springBoot整合mybatis

引入项目依赖

<!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!--mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <!--pagehelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>

以及数据库连接池和generater

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>

需要热部署的化加入配置（生产环境可以删除）
restart.include.mapper=/mapper-[\\w-\\.]+jar
restart.include.pagehelper=/pagehelper-[\\w-\\.]+jar

首先配置数据源（阿里的druid）
spring.datasource.url=jdbc:mysql://localhost:3306/leecx
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
spring.datasource.druid.test-on-borrow=true
spring.datasource.druid.stat-view-servlet.allow=true

然后mybatis的配置
mybatis的配置
mybatis.type-aliases-package=com.imooc.pojo
mybatis.mapper-locations=classpath:mapper/*.xml
通用mapper的配置
mapper.mappers=com.imooc.utils.MyMapper
mapper.not-empty=false
mapper.identity=MYSQL
分页插件的配置
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql
配置generater.xml然后main方法启动

书写crud

在springBoot启动类中写入扫描的路径

@SpringBootApplication
//扫描 mybatis mapper 包路径
@MapperScan(basePackages = "com.imooc.mapper")
public class ImoocApplication {

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

声明service调用dao

pagehelper的使用

传入page，pageSize
在方法前使用
 PageHelper.startPage(page, pageSize);

将查询到的对象封装到emps中返回pageInfo对象
PageInfo page = new PageInfo(emps, 5);

springboot事务

事物的隔离级别

1、DEFAULT
默认隔离级别
2、READ_UNCOMMITTED
读未提交，即能够读取到没有被提交的数据
3、READ_COMMITED
读已提交，即能够读到那些已经提交的数据
4、REPEATABLE_READ
重复读取，即在数据读出来之后加锁
5、SERLALIZABLE
串行化，最高的事务隔离级别

image.png

事物的传播行为

PROPAGATION_REQUIRED
如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
PROPAGATION_SUPPORTS
如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。
PROPAGATION_MANDATORY
如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
PROPAGATION_REQUIRES_NEW
总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
PROPAGATION_NOT_SUPPORTED
总是非事务地执行，并挂起任何存在的事务。
PROPAGATION_NEVER
总是非事务地执行，如果存在一个活动事务，则抛出异常
PROPAGATION_NESTED
如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

方法上加入注解
@Transactional(propagation = Propagation.SUPPORTS)

springBoot整合redis

引入依赖

<!-- 引入 redis 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置redis
redis的数据库索引（默认为0）
spring.redis.database=1
redis的服务器地址
spring.redis.host=192.168.1.191
redis服务器连接端口
spring.redis.port=6379
redis服务器连接密码（默认为空）
spring.redis.password=
连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=1000
连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
连接池最大空闲连接
spring.redis.pool.max-idle=10
连接池最小空闲连接
spring.redis.pool.min-idle=2
连接超时时间（毫秒）
spring.redis.timeout=0

代码

@Autowired
    private StringRedisTemplate strRedis;
        
    @RequestMapping("/test")
    public IMoocJSONResult test() {
        
        strRedis.opsForValue().set("imooc-cache", "hello 慕课网~~~~~~");
        
        SysUser user = new SysUser();
        user.setId("100111");
        user.setUsername("imooc");  
        strRedis.opsForValue().set("json:user", JsonUtils.objectToJson(user));
        
        SysUser jsonUser = JsonUtils.jsonToPojo(strRedis.opsForValue().get("json:user"), SysUser.class);
        
        return IMoocJSONResult.ok(jsonUser);
    }

springBoot整合定时任务task

使用注解@EnableScheduling开启定时任务，会自动扫描
定义一个@Component作为组件被容器扫描
表达式生成位置：http://cron.qqe2.com

第一步：打开定时任务的开关

//开启定时任务
//扫描 所有需要的包, 包含一些自用的工具类包 所在的路径
@ComponentScan(basePackages= {"com.imooc", "org.n3r.idworker"})
@EnableScheduling
public class ImoocApplication {

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

代码

@Component
public class TestTask {

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    // 定义每过3秒执行任务
//    @Scheduled(fixedRate = 3000)每隔三秒打印
//  @Scheduled(cron = "4-40 * * * * ?")表达式只能写6位，年不支持
    public void reportCurrentTime() {
        System.out.println("现在时间：" + dateFormat.format(new Date()));
    }
}

springBoot异步执行程序

使用注解@EnableAsync开启异步，会自动扫描
//开启异步调用方法
@EnableAsync
public class ImoocApplication {

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

代码

@Component
public class AsyncTask {
    
    @Async
    public Future<Boolean> doTask11() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("任务1耗时:" + (end - start) + "毫秒");
        return new AsyncResult<>(true);
    }
    
    @Async
    public Future<Boolean> doTask22() throws Exception {
        long start = System.currentTimeMillis();
        Thread.sleep(700);
        long end = System.currentTimeMillis();
        System.out.println("任务2耗时:" + (end - start) + "毫秒");
        return new AsyncResult<>(true);
    }
 }

springBoot整合拦截器

1使用注解@Configuration配置拦截器
2继承WebMvconfigurerAdapter
3重写addInterceptors添加需要拦截地址

@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        /**
         * 拦截器按照顺序执行
         */
        registry.addInterceptor(new TwoInterceptor()).addPathPatterns("/two/**")
                                                     .addPathPatterns("/one/**");
        registry.addInterceptor(new OneInterceptor()).addPathPatterns("/one/**");
        
        super.addInterceptors(registry);
    }

}

代码

public class OneInterceptor implements HandlerInterceptor  {

    /**
     * 在请求处理之前进行调用（Controller方法调用之前）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
            Object object) throws Exception {
        
        System.out.println("被one拦截，放行...");
        return true;
        
        /*if (true) {
            returnErrorResponse(response, IMoocJSONResult.errorMsg("被one拦截..."));
        }
        
        return false;*/
    }
    
    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
            Object object, ModelAndView mv)
            throws Exception {
        // TODO Auto-generated method stub
        
    }
    
    /**
     * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行
     * （主要是用于进行资源清理工作）
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
            Object object, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub
        
    }
    
    public void returnErrorResponse(HttpServletResponse response, IMoocJSONResult result) 
            throws IOException, UnsupportedEncodingException {
        OutputStream out=null;
        try{
            response.setCharacterEncoding("utf-8");
            response.setContentType("text/json");
            out = response.getOutputStream();
            out.write(JsonUtils.objectToJson(result).getBytes("utf-8"));
            out.flush();
        } finally{
            if(out!=null){
                out.close();
            }
        }
    }
}