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

2017-06-21 本文已影响1040人 yubang

为什么要使用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标签变成<packaging>war</packaging>

然后再用maven build一下：

打包配置

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

猜你喜欢

热点阅读