从0开始编写一个spring boot 应用

为什么要使用spring boot？

入门简单，无需编写大量的xml文件来配置应用
内置tomcat，可以生成直接运行的独立jar文件
简化了spring框架一些繁琐的开发方式，提供很多与第三方库的结合

使用eclipse新建一个spring boot工程

1.先在eclipse官网下载一个eclipse EE
2.new -> Maven Project

新建maven项目

3.填写项目信息

选择项目路径

选择quickstart

填写项目默认包名

** 安装spring boot依赖 **
在pom.xml文件添加一点点东西（保存的时候eclipse会自动下载依赖），整个文件如下：

<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>demo</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

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

	<dependencies>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

	</dependencies>
</project>

路由配置（输出hello world）

在默认生成的App.java文件修改成下面的代码：

package demo.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
@EnableAutoConfiguration
public class App  extends SpringBootServletInitializer implements EmbeddedServletContainerCustomizer {
	
	@RequestMapping("/")
	@ResponseBody
	String home() {
		return "Hello World!";
	}
	
    public void customize(ConfigurableEmbeddedServletContainer container) {  
        container.setPort(8000);  
    }  
	
    public static void main( String[] args ){
    	SpringApplication.run(App.class, args);
    }
}

然后我们运行这个文件，在浏览器访问 http://127.0.0.1:8000/ 即可看到效果。

我们来分析这个文件做了什么：

其中main方法的代码就是启动spring boot应用
继承SpringBootServletInitializer 类实现EmbeddedServletContainerCustomizer 接口编写customize方法其实是为了修改spring boot应用监听的端口
类的两个修饰器，@Controller是声明是一个控制器类，@EnableAutoConfiguration大概是自动加载一些bean
我们输出Hello World!的方法也有两个修饰器，@RequestMapping("/")是绑定路由，就是浏览器域名端口后面的一段字符串（不包括get参数），@ResponseBody表示输出字符串到浏览器

也许你会问，我如何限制get或者post方法请求该方法？

@RequestMapping(value="/", method=RequestMethod.POST)
	@ResponseBody
	String home() {
		return "Hello World!";
	}

get请求： RequestMethod.GET
post请求：RequestMethod.POST
put请求： RequestMethod.PUT
delete请求： RequestMethod.DELETE

现在可以限制请求方式了，但是我想正则匹配路由又该如何处理呢？

@RequestMapping("/test/{a}/*/{b:\\d+}")
	@ResponseBody
	public String index(@PathVariable int b, @PathVariable String a){
		System.out.println(a);
		System.out.println(b);
		return "test!";
	}

请求 http://127.0.0.1:8000/test/cbd/qwe/123 就可以看到效果！

{XXX}来匹配一个任意字符串
{xxx:正则表达式}来匹配符合规则的字符串
*匹配任意字符串
@PathVariable 修饰器把{X}的内容注入方法的参数里面

GET，POST参数获取

@RequestMapping("/test")
	@ResponseBody
	public String test(HttpServletRequest request){
		return request.getParameter("a");
	}

使用HttpServletRequest 对象的getParameter方法即可获取get或者post参数，如果参数不存在则返回null

输出结果设置headers

@RequestMapping(value="/test2", produces="text/plain")
	@ResponseBody
	public String test2(HttpServletResponse response){
		response.setHeader("own", "m");
		return "ok";
	}

修改content-type需要在修饰器的produces参数指定
自定义header调用setHeader方法即可

** 上传和下载文件 **

先看demo代码：


@Bean
	public MultipartConfigElement multipartConfigElement() {
		MultipartConfigFactory factory = new MultipartConfigFactory();
		factory.setMaxFileSize("128KB");
		factory.setMaxRequestSize("128KB");
		return factory.createMultipartConfig();
	}

@RequestMapping(value = "/upload", method = RequestMethod.POST)
	@ResponseBody
	public String upload(@RequestParam("file") MultipartFile file, HttpServletResponse response) throws IOException {
		response.setContentType("application/octet-stream");
		OutputStream os = response.getOutputStream();
		os.write(file.getBytes());
		return "upload!";
	}

其实很简单，接收文件只要在参数加上@RequestParam("file") MultipartFile file。"file"是post文件的变量名字

下载文件，先拿输出response.getOutputStream();。当然记得要设置content-type

模板渲染

这里使用了Thymeleaf模板引擎，其他模板引擎实在搜不出可运行方案。

第一步添加依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

第二步，在src/main/resources/templates文件夹编写模板文件，以.html结尾

第三步，编写代码返回模板

package demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class Debug {

	@RequestMapping("/index")
	public String index2(){
		return "web";
	}
	
}

注意返回的字符串不需要加上.html。

静态文件处理

新建一个类（这里是StaticConfig），继承WebMvcConfigurerAdapter类，重写addResourceHandlers方法，代码如下：

package demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class StaticConfig extends WebMvcConfigurerAdapter {
	
	@Override
    public void addResourceHandlers(ResourceHandlerRegistry resourceHandlerRegistry) {
        resourceHandlerRegistry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
        super.addResourceHandlers(resourceHandlerRegistry);
    }
	
}

静态文件放在src/main/resources/static文件夹即可

当然为了让配置生效，我们需要在主类增加注解@ComponentScan("demo.config")，demo.config换成你新建类的包名

允许跨域请求

只需要往入口类添加下面代码：

// 允许跨域请求
	@Bean
	public WebMvcConfigurer corsConfigurer() {
		return new WebMvcConfigurerAdapter() {
			@Override
			public void addCorsMappings(CorsRegistry registry) {
				registry.addMapping("/**").allowedOrigins("*");
			}
		};
	}

数据库操作

1.第一步当然是引入依赖咯，往pom.xml里面添加下面代码：

<!-- 与数据库操作相关的依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<!-- 使用数据源 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.14</version>
		</dependency>
		<!-- mysql -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<!-- mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.2</version>
		</dependency>

2.新建一个类用于配置数据库信息

package demo.config;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

@Configuration
@PropertySource(value="classpath:/demo/config/db_local.properties", ignoreResourceNotFound=true)
public class MyBatisConfig {
	
	@Value("${driverClassName}")
	private String driverClassName;
	
	@Value("${url}")
	private String url;
	
	@Value("${db_username}")
	private String username;
	
	@Value("${password}")
	private String password;
	
	/**
     * 创建数据源
     * @Primary 该注解表示在同一个接口有多个实现类可以注入的时候，默认选择哪一个，而不是让@autowire注解报错 
     */
    @Bean
    //@Primary
    public DataSource getDataSource() throws Exception{
        Properties props = new Properties();
        props.put("driverClassName", this.driverClassName);
        props.put("url", this.url);
        props.put("username", this.username);
        props.put("password", this.password);
        return DruidDataSourceFactory.createDataSource(props);
    }

    /**
     * 根据数据源创建SqlSessionFactory
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource ds) throws Exception{
        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        fb.setDataSource(ds);//指定数据源(这个必须有，否则报错)
        //下边两句仅仅用于*.xml文件，如果整个持久层操作不需要使用到xml文件的话（只用注解就可以搞定），则不加
        //fb.setTypeAliasesPackage("com.xxx.firstboot.domain");//指定基包
        //fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));//指定xml文件位置
        
        return fb.getObject();
    }
	
}

当然入口类记得加上扫描（@ComponentScan("demo.config")）

上面数据库密码那些是读取了配置文件所以新建一个配置文件（配置文件读取参考下文说明）

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/map?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
db_username=root
password=root

3.定义操作数据表的接口

import java.util.List;

import org.apache.ibatis.annotations.Select;

public interface SpecialtyMapper {
	
	@Select("select * from specialty where province = #{province};")
	List<demo.dao.SpecialtyDao> getSpecialtyList(String province);
	
}

当然，我们要在入口类用修饰器扫描这些模型类，@MapperScan("demo.mapper")

trip.footprint.dao.SpecialtyDao只是一个普通的java类，用于存储查询到的数据

package demo.dao;

import java.sql.Timestamp;

public class SpecialtyDao {

	private int id;
	private String province;
	private String title;
	private String img;
	private Timestamp create_time;
	private Timestamp update_time;

	public int getId() {
		return id;
	}

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

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getImg() {
		return img;
	}

	public void setImg(String img) {
		this.img = img;
	}

	public Timestamp getCreate_time() {
		return create_time;
	}

	public void setCreate_time(Timestamp create_time) {
		this.create_time = create_time;
	}

	public Timestamp getUpdate_time() {
		return update_time;
	}

	public void setUpdate_time(Timestamp update_time) {
		this.update_time = update_time;
	}

}

4.在controller中使用

package demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Debug {
	
	@Autowired
	private demo.mapper.SpecialtyMapper specialtyMapper;
	
	@RequestMapping("/abc")
	@ResponseBody
	public String index(){
		specialtyMapper.getSpecialtyList("广东省");
		return "ok";
	}
	
}

session放于redis

新建一个java类

package trip.footprint.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.session.data.redis.config.ConfigureRedisAction;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;

@Configuration
@EnableRedisHttpSession
@PropertySource(value = "classpath:/trip/footprint/config/redis_bae.properties")
public class SessionConfig {
	@Value("${redisHost}")
	private String redisHost;

	@Value("${redisPort}")
	private int redisPort;

	@Value("${redisPassword}")
	private String redisPassword;

	@Value("${redisDb}")
	private int redisDb;
	
	@Bean
	public static ConfigureRedisAction configureRedisAction() {
	    return ConfigureRedisAction.NO_OP;
	}
	
	@Bean
	public JedisConnectionFactory connectionFactory() {
		JedisConnectionFactory factory = new JedisConnectionFactory();
		factory.setHostName(redisHost);
		factory.setPort(redisPort);
		if(redisDb!=-1){
			factory.setDatabase(redisDb);
		}
		if (!redisPassword.equals("")) {
			factory.setPassword(redisPassword);
		}
		return factory;
	}

}

然后记得用@ComponentScan("demo.config")来扫描加载

由于代码读取配置文件，所以新建一个配置文件

redisHost=127.0.0.1
redisPort=6379
redisPassword=
redisDb=0

controller分离成多个文件

其实每一个controller都是一个java类，只是类上面有一个修饰器@Controller或者@RestController。当然记得用@ComponentScan("xxx.xxx")来扫描加载

依赖注入

首先想把类A作为一个变量注入类B，就需要用修饰器@ComponentScan扫描类A和类B的包，同时类A要在类上面加入修饰器@Component，类B变量上面添加修饰器 @Autowired。

类A代码：

package demo.data;

import org.springframework.stereotype.Component;

@Component
public class A {
	
	public String data = "good!";
	
}

类B代码：

package demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Debug {
	
	@Autowired
	private demo.mapper.SpecialtyMapper specialtyMapper;
	
	@Autowired
	private demo.data.A a;
	
	@RequestMapping("/abc")
	@ResponseBody
	public String index(){
		specialtyMapper.getSpecialtyList("广东省");
		return a.data;
	}
	
}

读取配置文件

读取配置文件需要使用修饰器，@PropertySource(value = "classpath:/trip/footprint/config/redis_bae.properties")。classpath后面跟着的是配置文件路径。当然入口类记得用@ComponentScan("demo.config")扫描包。加载配置文件，当然要注入变量，用修饰器@Value("${变量名}")即可注入。代码如下：

package demo.config;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

@Configuration
@PropertySource(value="classpath:/demo/config/db_local.properties", ignoreResourceNotFound=true)
public class MyBatisConfig {
	
	@Value("${driverClassName}")
	private String driverClassName;
	
	@Value("${url}")
	private String url;
	
	@Value("${db_username}")
	private String username;
	
	@Value("${password}")
	private String password;
	
	/**
     * 创建数据源
     * @Primary 该注解表示在同一个接口有多个实现类可以注入的时候，默认选择哪一个，而不是让@autowire注解报错 
     */
    @Bean
    //@Primary
    public DataSource getDataSource() throws Exception{
        Properties props = new Properties();
        props.put("driverClassName", this.driverClassName);
        props.put("url", this.url);
        props.put("username", this.username);
        props.put("password", this.password);
        return DruidDataSourceFactory.createDataSource(props);
    }

    /**
     * 根据数据源创建SqlSessionFactory
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource ds) throws Exception{
        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        fb.setDataSource(ds);//指定数据源(这个必须有，否则报错)
        //下边两句仅仅用于*.xml文件，如果整个持久层操作不需要使用到xml文件的话（只用注解就可以搞定），则不加
        //fb.setTypeAliasesPackage("com.xxx.firstboot.domain");//指定基包
        //fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));//指定xml文件位置
        
        return fb.getObject();
    }
	
}

配置文件如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/map?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
db_username=root
password=root

日志输出

在src/main/resources新建一个文件，写入下面内容：

logging.file=log/myapp.log
logging.level.org.springframework.web=DEBUG
logging.level.root=DEBUG

代码输出日志，代码如下：

package demo.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.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Debug {
	
	@Autowired
	private demo.mapper.SpecialtyMapper specialtyMapper;
	
	@Autowired
	private demo.data.A a;
	
	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	
	@RequestMapping("/abc")
	@ResponseBody
	public String index(){
		logger.debug("ceshi");
		logger.info("对的");
		specialtyMapper.getSpecialtyList("广东省");
		return a.data;
	}
	
}

导出成war

其实主要是修改pom.xml，添加下面代码：

<!-- 打包成war需要 -->
		<dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-tomcat</artifactId>  
            <scope>provided</scope>  
        </dependency>  
<!-- end -->

<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
			<plugin>
			  <artifactId>maven-war-plugin</artifactId>
			  <version>3.0.0</version>
			  <configuration>
			<failOnMissingWebXml>false</failOnMissingWebXml>
		</configuration>
			</plugin>
		</plugins>
	</build>

修改pom.xml文件的packaging标签变成war

然后再用maven build一下：

打包配置

交流技术请点击这里

从0开始编写一个spring boot 应用

使用moquette搭建mqtt服务

maven web 应用配置