什么是spring boot
Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。
为什么要使用spring boot
Spring IO大量的XML配置以及复杂的依赖管理一直是其饱受非议的一点。而Boot的实现不仅仅实现了免XML配置的开发体验,而且在一些场景中甚至不需要编写繁琐的import语句。Spring Boot的目标不在于为已解决的问题域提供新的解决方案,而是为平台带来另一种开发体验,从而简化对这些已有技术的使用。对于已经熟悉Spring生态系统的开发人员来说,Boot是一个很理想的选择,不过对于采用Spring技术的新人来说,Boot提供一种更简洁的方式来使用这些技术。
使用Spring Boot
要进行打包和分发的工程会依赖于像
Maven或
Gradle这样的构建系统。为了简化依赖图,Boot的功能是模块化的,通过导入Boot所谓的“starter”模块,可以将许多的依赖添加到工程之中。官方网站给我们提供了集成相关服务的项目例子,我们直接下载
https://start.spring.io/。
为了更容易地管理依赖版本和使用默认配置,框架提供了一个parent POM,工程可以继承它。Spring Boot工程的样例POM文件定义如下所示:
<?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.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.2-SNAPSHOT</version>
<!-- Boot默认打包为jar -->
<packaging>war</packaging>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.4.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-web-services</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 这里指定打包的时候不再需要tomcat相关的包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<!-- 打包时需要添加以下依赖 -->
<!--<scope>provided</scope>-->
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Spring Boot JDBC -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- 热部署 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<!-- optional=true,依赖不会传递,该项目依赖devtools;之后依赖myboot项目的项目如果想要使用devtools,需要重新引入 -->
<optional>true</optional>
</dependency>
<!--整合cxf-->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.1.6</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.1.6</version>
</dependency>
<!-- HikariCP依赖 -->
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<!-- 版本号可以不用指定,Spring Boot会选用合适的版本 -->
</dependency>
<!-- mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<!-- 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.0</version>
</dependency>
<!-- httpclient -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient-cache</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.1.2</version>
</dependency>
<!-- json-lib-->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<!-- 加入静态文件和jsp -->
<!--对jsp的支持-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<!-- 打包时需要添加以下依赖 -->
<!--<scope>provided</scope>-->
</dependency>
<!--配置servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
<!-- MYSQL -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.7</version>
<scope>system</scope>
<systemPath>${basedir}/src/lib/mysql-connector-java-5.1.7-bin.jar</systemPath>
</dependency>
<!--添加外部依赖-->
<dependency>
<groupId>Ice</groupId>
<artifactId>Ice</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${basedir}/src/lib/jsonrpc4j-0.27.jar</systemPath>
</dependency>
<!--<!– https://mvnrepository.com/artifact/javax.xml.bind/jaxb-api –>-->
<!--<dependency>-->
<!--<groupId>javax.xml.bind</groupId>-->
<!--<artifactId>jaxb-api</artifactId>-->
<!--<version>2.2.11</version>-->
<!--</dependency>-->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- 打包跳过测试 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<!-- maven打包的时候告诉maven不需要web.xml,否刚会报找不到web.xml错误 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.4</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
<!-- 将外部依赖打入war包的lib目录下 -->
<webResources>
<resource>
<directory>src/lib</directory>
<targetPath>WEB-INF/lib/</targetPath>
<includes>
<include>**/*.jar</include>
</includes>
</resource>
</webResources>
</configuration>
</plugin>
</plugins>
<!-- 手工设置resource -->
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
<resource>
<directory>src/main/webapp</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
</resources>
</build>
</project>
构建Boot web应用
1.在配置文件中引入Spring Boot的web依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
spring-boot-starter-web 包含了很多内容,spring-webmvc、spring-web、jackson、validation、tomcat、starter。
2.开始编写代码,由于Maven默认编译路径为 src/main/java 下面的源码,所以,默认设置下,需要创建一些文件夹。
编写文件src\main\java\com\example\hello\HelloController.java:
package com.example.hello;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* Created by wuhaochao on 2017/7/12.
*/
@RestController
@RequestMapping("/hello")
public class HelloController {
@RequestMapping("/index")
public String index(@RequestParam String name) {
// return "hello word" + name;
return "index";
}
@RequestMapping("/info")
public Map<String, String> getInfo(@RequestParam String name) {
Map<String, String> map = new HashMap<>();
map.put("name", name);
return map;
}
@RequestMapping("/list")
public List<Map<String, String>> getList() {
List<Map<String, String>> list = new ArrayList<>();
Map<String, String> map = null;
for (int i = 1; i <= 5; i++) {
map = new HashMap<>();
map.put("name", "Shanhy-" + i);
list.add(map);
}
return list;
}
}
@RestController因为我们例子是写一个web应用,因此写的这个注解,这个注解相当于同时添加@Controller
和@ResponseBody
注解。
创建一个Application
类:
package com.example;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
//@EnableScheduling//启动定时探测
@EnableAsync//启动自定义线程池
@EnableTransactionManagement//启动事物管理
@SpringBootApplication
public class DemoApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(DemoApplication.class);
}
@Bean
public ServletRegistrationBean restServlet() {
//注解扫描上下文
AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
// base package 这里指定到controller不指定*,因为配置有定时任务,容易造成bean冲突,导致定时任务执行2次
applicationContext.scan("com.example.controller");
// /通过构造函数指定dispatcherServlet的上下文
DispatcherServlet rest_dispatcherServlet = new DispatcherServlet(applicationContext);
// 用ServletRegistrationBean包装servlet
ServletRegistrationBean registrationBean = new ServletRegistrationBean(rest_dispatcherServlet);
registrationBean.setLoadOnStartup(1);
//指定urlmapping
registrationBean.addUrlMappings("/webapp/*");
// 指定name,如果不指定默认为dispatcherServlet
registrationBean.setName("webapp");
return registrationBean;
}
@Bean
public Object testBean(PlatformTransactionManager platformTransactionManager) {
System.out.println(">>>>>>>>>>>>>>>>>" + platformTransactionManager.getClass().getName() + "<<<<<<<<<<<<<<<<<<<<<");
return new Object();
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
注意Spring Boot建议将我们main
方法所在的这个主要的配置类配置在根包src名下。
继承SpringBootServletIntializer和方法configure是后期为实现跳转前端页面的配置。
启动项目就可以在浏览器访问了。
数据访问
在配置文件application.properties中配置数据源:
#数据源设置
spring.datasource.url=jdbc:mysql://localhost:3306/stu_info
spring.datasource.username=root
spring.datasource.password=111111
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=10
#指定连接池等待连接返回的最大等待时间,毫秒单位.
spring.datasource.max-wait=10000
#指定必须保持连接的最小值
spring.datasource.min-idle=5
#指定连接池中最大的活跃连接数.
spring.datasource.secondary.max-active=50
spring.datasource.initial-size=5
spring.datasource.validation-query=SELECT 1
spring.datasource.test-on-borrow=false
spring.datasource.test-while-idle=true
spring.datasource.time-between-eviction-runs-millis=18800
spring.datasource.jdbc-interceptors=ConnectionState;SlowQueryReport(threshold=0)
#mybatis数据文件路径
mybatis.mapper-locations=com/example/mapper/sql/*Mapper.xml
mybatis.type-aliases-package=com.example.entity
添加mybatis相关依赖:
<!-- mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<!-- 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.0</version>
</dependency>
编写mybatis:
package com.example.mapper;
import com.example.entity.TranscationBean;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* Created by wuhaochao on 2017/7/24.
*/
@Mapper
public interface TranscationMapper {
// 获取交易信息
List<TranscationBean> getTranscation();
// 插入交易信息
int insertTranscationBean(@Param("transcationBean") TranscationBean transcationBean);
// 批量插入交易信息
int insertTranscationList(@Param("transcationList") List<TranscationBean> transcationList);
}
对于的xml文件:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.TranscationMapper">
<!-- type为实体类TranscationBean,包名已经配置,可以直接写类名 -->
<resultMap id="transcationMap" type="TranscationBean">
<id property="hash" column="transactionHash"/>
<result property="transactionIndex" column="transactionIndex"/>
<result property="blockHash" column="blockHash"/>
<result property="blockNumber" column="blockNumber"/>
<result property="from" column="from"/>
<result property="to" column="to"/>
<result property="nonce" column="nonce"/>
<result property="gasPrice" column="gasPrice"/>
<result property="gas" column="gas"/>
<result property="input" column="input"/>
<result property="value" column="value"/>
<result property="timestamp" column="timestamp"/>
</resultMap>
<!-- 查询最新交易信息 -->
<select id="getTranscation" resultMap="transcationMap" resultType="TranscationBean">
select * from transaction_info t order by t.TIMESTAMP desc
</select>
<!-- 批量插入交易信息 -->
<insert id="insertTranscationList" parameterType="java.util.List">
insert into transaction_info VALUES
<foreach collection="transcationList" item="trsList" index="index" open="(" close=")" separator=",">
#{trsList.hash},#{trsList.transactionIndex},#{trsList.blockHash},
#{trsList.blockNumber},#{trsList.from},#{trsList.to},
#{trsList.nonce},#{trsList.gasPrice},#{trsList.gas},
#{trsList.input},#{trsList.value},#{trsList.timestamp}
</foreach>
</insert>
<!-- 插入交易信息 -->
<insert id="insertTranscation" parameterType="TranscationBean">
insert into transaction_info VALUES(
#{hash},#{transactionIndex},#{blockHash},
#{blockNumber},#{from},#{to},
#{nonce},#{gasPrice},#{gas},
#{input},#{value},#{timestamp}
)
</insert>
</mapper>
配置mybatis分页插件:
package com.example.mapper;
import com.github.pagehelper.PageHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
/**
* Created by wuhaochao on 2017/7/21.
*/
@Configuration
public class MyBatisConfiguration {
private static final Logger logger = LoggerFactory.getLogger(MyBatisConfiguration.class);
@Bean
public PageHelper geHelper() {
logger.info("注册mybatis分页插件");
PageHelper pageHelper = new PageHelper();
Properties properties = new Properties();
properties.setProperty("offsetAsPageNum", "true");
properties.setProperty("rowBoundsWithCount", "true");
properties.setProperty("reasonable", "true");
pageHelper.setProperties(properties);
return pageHelper;
}
}
控制层调用:
package com.example.controller;
import com.example.entity.TranscationBean;
import com.example.mapper.TranscationMapper;
import com.example.unitl.Until;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Created by wuhaochao on 2017/7/21.
*/
/**
* 交易
*/
@RequestMapping("/transcation")
@RestController
public class TranscationController {
@Autowired
private TranscationMapper transcationMapper;
/**
* 获取全部交易信息
*
* @return
* @throws Throwable
*/
@RequestMapping("/getTransInfo")
public Object getTranscationInfo() throws Throwable {
List<TranscationBean> list = transcationMapper.getTranscation();
return list;
}
/**
* 分页获取交易信息
*
* @param pagesize
* @return
* @throws Throwable
*/
@RequestMapping("/getTransInfo/{pagesize}")
public Object getTranscationInfoByPage(@PathVariable("pagesize") Integer pagesize) throws Throwable {
PageHelper.startPage(1, pagesize);
List<TranscationBean> list = transcationMapper.getTranscation();
return new PageInfo(list);
}
}
定时任务
Spring Boot定时任务相对Spring quartz来说更简单。
定义一个定时任务:
package com.example.Scheduled;
/**
* Created by wuhaochao on 2017/7/21.
*/
import com.example.mapper.BlockMapper;
import com.example.mapper.TranscationMapper;
import com.example.theadPoolConfig.AsyncTranscationTask;
import com.example.unitl.Until;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
/**
* 定时任务,每五秒探测一次区块链中的是否存在最新交易信息
*/
@Component
public class MyScheduled {
private static final Logger logger = LoggerFactory.getLogger(MyScheduled.class);
@Autowired
private AsyncTranscationTask asyncTranscationTask;
@Autowired
private BlockMapper blockMapper;
/*每天每5秒执行一次*/
@Scheduled(cron = "0/5 * * * * ?")
@Transactional
public void executeTask2() {
// 获取最新区块编号
try {
int blockNumberNew = Integer.parseInt(
Until.encodeHexTodecimal(Until.JSONRPCClient(new Object[]{},
"eth_blockNumber").toString()));
// 查询数据库中存储的最新区块数据
int blockNumberDataSource = blockMapper.getBlockNum();
for (int i = blockNumberDataSource + 1; i <= blockNumberNew; i++) {
asyncTranscationTask.insertTransTask(i);
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
}
@Scheduled注解定义了定时任务
启动程序中需要加上@EnableScheduling注解启动定时任务探测。
多线程
Spring Boot有自己默认的线程池,这里我们自定义一个自己的线程池。
配置线程池:
package com.example.theadPoolConfig;
/**
* Created by wuhaochao on 2017/7/25.
*/
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 创建自定义线程池
*/
@Configuration
@EnableAsync
public class TaskExecutePool {
@Bean
public Executor myTaskAsyncPool() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(50);
executor.setQueueCapacity(1000);
executor.setKeepAliveSeconds(300);
// rejection-policy:当pool已经达到max size的时候,如何处理新任务
// CALLER_RUNS:不在新线程中执行任务,而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
}
@EnableAsync注解并发。
使用自定义线程池:
package com.example.theadPoolConfig;
import com.example.entity.BlockInfoBean;
import com.example.entity.TranscationBean;
import com.example.mapper.BlockMapper;
import com.example.mapper.TranscationMapper;
import com.example.unitl.Until;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* Created by wuhaochao on 2017/7/25.
*/
@Component
public class AsyncTranscationTask {
private static final Logger logger = LoggerFactory.getLogger(AsyncTranscationTask.class);
@Autowired
private TranscationMapper transcationMapper;
@Autowired
private BlockMapper blockMapper;
//myTaskAsynPool即配置线程池的方法名,此处如果不写自定义线程池的方法名,会使用默认的线程池
@Async("myTaskAsyncPool")
public void insertTransTask(int i) throws InterruptedException {
logger.info("TranscationTask" + i + " started.");
//开始导入交易信息
String method_BlockByNumber = "eth_getBlockByNumber";
JSONObject objects = null;
List<TranscationBean> list = null;
JSONObject transtionObject = null;
TranscationBean transcation = null;
try {
objects = JSONObject.fromObject(Until.JSONRPCClient(new Object[]{i, true}, method_BlockByNumber));
} catch (Throwable throwable) {
throwable.printStackTrace();
}
//插入区块信息
BlockInfoBean blockInfoBean = new BlockInfoBean(objects);
blockMapper.insertBlockInfo(blockInfoBean);
if (JSONArray
.fromObject(objects.get("transactions")).size() > 0) {
list = new ArrayList<TranscationBean>();
for (java.util.Iterator tor = JSONArray
.fromObject(objects.get("transactions"))
.iterator(); tor.hasNext(); ) {
transtionObject = (JSONObject) tor.next();
transcation = new TranscationBean(transtionObject);
transcation.setTimestamp(Until.formatTimeMillis(objects.get("timestamp").toString()));
list.add(transcation);
}
//批量插入
transcationMapper.insertTranscationList(list);
}
}
}
启动程序中需要加上@
EnableAsync注解启动自定义线程池。
部署
Spring Boot默认打包为jar,按照官方文档操作即可,这里我们打包为war包,可以与前台静态页面交互的web应用。
POM文配置:
<!-- 加入静态文件和jsp -->
<!--对jsp的支持-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<!-- 打包时需要添加以下依赖 -->
<!--<scope>provided</scope>-->
</dependency>
<!--配置servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
<!-- 这里指定打包的时候不再需要tomcat相关的包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<!-- 打包时需要添加以下依赖 -->
<!--<scope>provided</scope>-->
</dependency>
<!-- 手工设置resource -->
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
<resource>
<directory>src/main/webapp</directory>
<includes>
<include>**/*</include>
</includes>
</resource>
</resources>
<!-- 打包跳过测试 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
<!-- maven打包的时候告诉maven不需要web.xml,否刚会报找不到web.xml错误 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.4</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
<!-- 将外部依赖打入war包的lib目录下 -->
<webResources>
<resource>
<directory>src/lib</directory>
<targetPath>WEB-INF/lib/</targetPath>
<includes>
<include>**/*.jar</include>
</includes>
</resource>
</webResources>
</configuration>
</plugin>
添加本地jar:
<!--添加外部依赖-->
<dependency>
<groupId>Ice</groupId>
<artifactId>Ice</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${basedir}/src/lib/jsonrpc4j-0.27.jar</systemPath>
</dependency>
以下为本人项目结构:主要是区块链的取数接口开发
源码下载链接:https://github.com/haochaowu/spring-boot