springboot环境搭建及入门必知

springboot环境搭建

导入springboot父项目依赖，目的是统一当前整合技术版本

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>

2、导入web启动器依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

3、控制器

package rr.tt.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import rr.tt.service.UserService;

import javax.annotation.Resource;

/**
* @author George
* @description 控制层
**/
@Controller
public class UserController {

@Autowired
private UserService userService;

@RequestMapping("/insert")
    @ResponseBody
    public String insert(){
        userService.insert();
System.out.println("控制器insert()");
        return "index";
}

@RequestMapping("/insert/ddd")
    @ResponseBody
    public String bbb(){
        userService.insert();
System.out.println("控制器insertddd()");
        return "indexddd";
}

//由于springboot默认不支持jsp，所以404
    @RequestMapping("/update")
    public String update(){
System.out.println("控制器update()");
        return "index";
}

}

4、主启动类

package rr.tt;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import rr.tt.controller.UserController;
import rr.tt.filter.SellFilter;

/**
* @author George
* @description springboot的应用程序入口
**/
@SpringBootApplication
//@ComponentScan(basePackages = "rr.tt")
public class UserApplication {
public static void main(String[] args) {

// Logger log= LoggerFactory.getLogger(UserController.class);
SpringApplication.run(UserApplication.class);
}
}

5、springboot配置文件

配置文件有两种：一是application.properties，二是application.yml

application.properties:

##服务器配置
server.port=9090
server.servlet.path=/springboot

application.yml:

##服务器配置
server:
  port: 9090
  servlet:
    path: /springboot

6、springboot中的注解

@Configuration<=>@SpringBootConfiguration

7、修改springboot的banner

在resources下创建banner.txt
把创建好的图标，复制其中
禁用banner
import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

/**
* Hello world!
*元注解
*/
@SpringBootApplication//springboot核心注解，用于标识启动类
public class SellerApplication
{
    public static void main( String[] args )
{
        //SpringApplication.run(SellerApplication.class,args);
        SpringApplication application=new SpringApplication(SellerApplication.class);
        //关闭banner
        application.setBannerMode(Banner.Mode.OFF);
application.run(args);
}
}

加载xml 配置文件

applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
   
    <bean id="productServiceImpl" class="com.henu.service.UserServiceImpl"></bean>
</beans>

加载外部xml文件：

@SpringBootApplication//springboot核心注解，用于标识启动类
@ImportResource(value={"classpath:applicationContext.xml"})
public class SellerApplication
{
public static void main( String[] args )
{

......

}

使用logback日志

导入依赖：

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-logging</artifactId>

<scope>compile</scope>

</dependency>

编辑日志配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    
    
    
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d %p (%file:%line\)- %m%n</pattern>
            
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    
    
    
    <appender name="demolog"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>log/demo.log</File>
        
        
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            
            <fileNamePattern>log/demo.%d.%i.log</fileNamePattern>
            
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                
                <maxFileSize>1KB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            
            <pattern>
%d %p (%file:%line\)- %m%n
            </pattern>
            
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
    
    
    

    <logger name="com.alibaba.springboot.controller" level="debug">
        <appender-ref ref="demolog" />
    </logger>
</configuration>

加载日志配置文件：

##logback
logging:
config: classpath:logback.xml

创建日志对象：

//创建日志对象
public static Logger log= LoggerFactory.getLogger(ProductServiceImpl.class);

jsp跳转

查看是否导入jsp和servlet依赖：

导入springboot支持jsp依赖：


<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>

Application.yml中配置视图跳转信息：

##spring mvc
spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp

Idea中配置jsp跳转路径：

打开工具栏中绿色开始图标的左边一个选项Edit Configurations 选择Spring boot 然后Working directorg 选择 $MODULE_DIR$ 如图：

热部署

12、项目热部署

1、在Maven的pom.xml文件中添加依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

</dependency>

2、继续在Maven的pom.xml文件中添加插件的配置

<build>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</configuration>

</plugin>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

如果是Eclipse，配置到这里，只要重启服务，热部署就会生效了。

但是IDEA的话，热部署还不会生效，因为devTools只会在类路径上的文件发生更改时才会自动重启，而IDEA默认不会自动编译。

解决方法有两种：

1、手动：修改完代码，按快捷键Ctrl+F9，手动构建项目，或者只修改单个类文件的话，按Ctrl+Shift+F9，重新编译该类文件，即可触发重启服务。

2、自动：

1）File -> Settings -> Compiler，勾选 Build Project automatically

2）按快捷键Ctrl+Shift+Alt+/，选择1.Registry...

3）勾选 compiler.automake.allow.when.app.running 即可

Spring Boot单元测试

SpringBoot单元测试目的:测试目标方法是否能正确执行

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

使用注解@RunWith和@SpringBootTest

@RunWith(SpringRunner.class)

@SpringBootTest(classes= {启动类.class})

public class TestApplication {

@Autowired

public XxxService servcie;

@Test

public void testXxx() {

servcie.insert();

}

定时器

注解：@EnableScheduling作用于配置类，表示启动定时任务

注解：@Scheduled(cron="0/2 * * * * ?")作用于方法，表示按指定周期执行该方法；cron为定时表达式，详见文档。

package rr.tt.boot;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

/**
* @author George
* @description
**/
@SpringBootConfiguration
@EnableScheduling
public class SellSpringBootConfigBean {
@Scheduled(cron = "0/2 * * * * ?")
public void startDo(){

System.out.println("定时器");

}
}

配置过滤器

定义过滤器：

package rr.tt.filter;

import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;

/**
* @author George
* @description
**/
public class SellFilter implements Filter {

@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("init");
}

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("doFilter......");
filterChain.doFilter(servletRequest,servletResponse);
}

@Override
public void destroy() {
System.out.println("destory");
}
}

配置过滤器：

/**配置过滤器*/
@Bean
public FilterRegistrationBean filterRegistrationBean() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    //指定过滤器
    filterRegistrationBean.setFilter(new SellFilter());
    //过滤器名称
    filterRegistrationBean.setName("RestWebFilter1");
    //设置过滤器拦截路径
    filterRegistrationBean.addUrlPatterns("/*");
    //设置过滤器执行顺序
    filterRegistrationBean.setOrder(1);
    return filterRegistrationBean;

}

配置拦截器

package rr.tt.interceptor;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

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

/**
* @author George
* @description
**/
public class SellInterceptor extends HandlerInterceptorAdapter {

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle");
return true;
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion");
}
}

配置拦截器：

package rr.tt.config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import rr.tt.interceptor.SellInterceptor;

/**
* @author George
* @description
**/
@SpringBootConfiguration
public class SellInterceptorConfig implements WebMvcConfigurer {

@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new SellInterceptor()).addPathPatterns("/insert");
}
}

【注】将preHandle return false;

配置servlet

package rr.tt.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
* @author George
* @description
**/
public class SellServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("doget()");
        //输出json格式
        PrintWriter writer = resp.getWriter();
writer.write("xxx");
writer.close();
}
}

配置servlet方式一：

/***
* 配置servlet
* @return
*/
@Bean
public ServletRegistrationBean servletRegistrationBean(){
ServletRegistrationBean servletRegistrationBean=new ServletRegistrationBean(new SellServlet(),"/updateSell");
return servletRegistrationBean;
}

配置servlet方式二：

@WebServlet("/updateSell")
public class SellServlet extends HttpServlet{
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("servlet......");
PrintWriter out = resp.getWriter();
out.print("{name:admin}");
out.flush();
out.close();

}

主类添加注解：

@SpringBootApplication//springboot核心注解，用于标识启动类
@ServletComponentScan(basePackages="com.offcn.springboot.servlet")
public class SellerApplication
{
public static void main( String[] args )

}