springboot 实战之一站式开发体验 - 好文

都说springboot是新形势的主流框架工具，然而我的工作中并没有真正用到springboot；

　　都说springboot里面并没有什么新技术，不过是组合了现有的组件而已，但是自己却说不出来；

　　都说springboot让开发更简单，然而对于刚转换过来使用的时候总会发现各种不适应；

　　网上查过许多的教程，下载过demo来玩，却无法用于实战，着实可惜。

　　最近有个项目终于用springboot来开发了，一切从0开始，刚好可以练练手。来谈谈几点经验吧！（注：本文非教程，请当闲聊谈资）

1. 入门？

　　springboot 的入门demo在spring官网可以直接下载，可以使用 maven 开发，https://start.spring.io/
下载下来，运行main()方法就可以启动服务了。

　　一个简单的helloworld就ok了，是不是超简单？再也不用复杂的搭建过程了。（不过说实话，这个过程相当于我之前有一套有一套代码模板，然后改改名字就成了新项目代码一样，没什么了不起）

　　不过，有空的话还是有必要看一下完整点的入门demo教程: https://spring.io/guides/gs/rest-service/
（手动搭建服务很快这是真的）

2. 如何接入各常用组件及配置？

　　这个需求是很强烈的，一个空白的框架是没有啥用的，因为我们必定要基于: 数据库、缓存、zk、mq、日志、mongo、页面模板等等。。。
　　所以，如何配置？
　　三个步骤:
　　　　1. 引入组件依赖 dependency；
　　　　2. 在 bootstrap-xx.properties 文件中加入配置属性；
　　　　3. 在配置java文件中，new出相应实例或框架自己初始化实例以备用；

　　就单是这点来说，其实springboot和spring的xml配置方式步骤是一样一样的，三步式导入。不过显然java代码写得更复杂和难找，xml更直观！（这里先忽略dependecy依赖的个数对比）

3. 如何做到加载动态配置？

　　在使用xml配置的方式时，我们可以使用 spring 的
org.springframework.beans.factory.config.PropertyPlaceholderConfigurer

　　组件，去加载一个配置中心的值，从而实现替换各种连接的作用，使其脱离代码的硬编码；
 <bean class
="com.xx.zk.property.PropertyPlaceholderConfigurer"> <property name
="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" /> <property
name="ignoreResourceNotFound" value="true" /> <property name="locations"> <list>
<value>classpath*:/spring/conf.properties</value> </list> </property> </bean>
　　那么，在springboot中是怎么做的呢？ springboot 提供了多种配置文件共存的方式，比如:
bootstrap-prod.properties, bootstrap-dev.properties, 用于区分测试环境和生产环境的配置而不互相影响；

　　其大致原理为，环境准备好时，会触发监听器,然后加载相应配置文件：
// - org.springframework.boot.context.event.EventPublishingRunListener
@Overridepublic void contextLoaded(ConfigurableApplicationContext context) { for
(ApplicationListener<?> listener :this.application.getListeners()) { if
(listenerinstanceof ApplicationContextAware) { ((ApplicationContextAware)
listener).setApplicationContext(context); }
context.addApplicationListener(listener); }// 加载 bootstrap.properties,
bootstrap-dev.properties...// 在 ConfigFileApplicationListener 的
ApplicationPreparedEvent 事件中触发 this.initialMulticaster.multicastEvent( new
ApplicationPreparedEvent(this.application, this.args, context)); }
　　如果要使用配置中心，可以直接使用 spring-cloud-config
组件，配置即可，不说说实施这种配置中心着实难用，有能力的话都应自行定制开发一个统一配置中心（毕竟配置中心也是个技术活）；spring cloud config
使用可以参考这篇博文： http://blog.51cto.com/zero01/2171735 ，或者查看官网教程！

4. 如何注册 beans ?

　　1. 和spring一样，直接使用 @Service, @Controller, @Component... 注解直接注册简单的 bean;

　　2. 对于一些复合bean组件，需要单独配置，如数据库连接:

　　　　如 spring 中druid连接池的xml配置是这样的：
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
destroy-method="close"> <property name="url" value="${jdbc.url}" /> <property
name="driverClassName" value="${jdbc.driver}" /> <property name="maxActive"
value="${pool.maxPoolSize}" /> <property name="username" value
="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> <
propertyname="removeAbandoned" value="true" /> <property name
="removeAbandonedTimeout" value="${pool.removeAbandonedTimeout}" /> <property
name="maxWait" value="${pool.maxWait}" /> <property name
="timeBetweenEvictionRunsMillis" value="${pool.timeBetweenEvictionRunsMillis}"
/> <property name="minEvictableIdleTimeMillis" value
="${pool.minEvictableIdleTimeMillis}" /> <property name="validationQuery" value
="${pool.validationQuery} " /> <property name="testWhileIdle" value="true" /> <
propertyname="testOnBorrow" value="false" /> <property name="testOnReturn" value
="false" /> </bean>
　　而在 springboot 中，则是使用 java 代码直接创建:
@Bean(name = "druidDataSource") public DruidDataSource druidDataSource(){
DruidDataSource ds= new DruidDataSource(); ds.setUrl(config.getJdbcUrl());
ds.setDriverClassName(config.getDriverName());
ds.setMaxActive(config.getMaxPoolSize());
ds.setUsername(config.getJdbcUserName()); ds.setPassword(config.getJdbcPwd());
ds.setRemoveAbandoned(true); ds.setMaxWait(config.getJdbcMaxWait());
ds.setTimeBetweenEvictionRunsMillis(config.getTimeBetweenEvictionRunsMillis());
ds.setMinEvictableIdleTimeMillis(config.getMinEvictableIdleTimeMillis());
ds.setValidationQuery(config.getValidationQuery()); ds.setTestWhileIdle(true);
ds.setTestOnBorrow(false); ds.setTestOnReturn(false); return ds; }
　　3. 还有一种特殊的加载方式，值得注意，就是使用了 @Bean 注解，但是其直接new了一对象返回：
@Bean(name = "directHelloService") public HelloService directHelloService(){
HelloService service= new HelloService(); return service; }
　　这个有什么问题呢？因为我们的 service
一般都会依赖于其他的服务，所以，往往都会有依赖注入的过程，但是你使用了一个new创建，则没有了依赖注入问题了。因此，当你想直接使用这个服务的时候，很可能就会拿到一些空对象；

　　那怎么办？三个办法：

　　　　1. 没事就不要直接new有依赖的对象了;
　　　　2. 如果实在要new，需要在new的对象上添加注解 @DependsOn
注解标明需要依赖的组件，这样，在使用的时候就会再次去检测依赖，从而完成依赖注入了;
　　　　3. 自己手动完成依赖注入;
　　　　4. 将加载动作委托给springContext, 比如使用 getBean("xxx")
的方式获取，使其回归spring的自动依赖注入过程；（没有试验过）

　　单从这一点来讲，想完全摆脱 xml 束缚的 springboot, 还是显得有些力不从心！另外，使用 java
配置文件的另一个不好的地方是，配置文件散落在各处，很不直观！

5. 日志如何记录？

　　日志是必备工具。所以 springboot 默认集成了 logback 的日志组件，所以，我们要做的只是，配置好打印属性就好了；如在
bootstrap.properties 文件中添加如下：
logging.config=classpath:logback.xml
　　意思就是说，你将配置写入到 resources/logback.xml 中，其中的配置规则同理自不必细说；

6. 如何自定义 RequestMappingHandlerMapping ?

　　做一个web应用时，对webmvc的定制化配置是一定的。因为我们的包路径查找，可能会有自己一些特定的规则，所以需要自定义
RequestMappingHandlerMapping。这在 spring
中，则只需要注册一个requestMappingBean就可以了（要先排除系统自动扫描 @Controller 注解），如：
<bean name='requestMappingHandlerMapping' class
='com.xxx.cust.URLRequestMappingHandlerMapping'> <property name="interceptors">
<list>  <beanclass="com.xxx.interceptor.SessionInterceptor">
</bean> </list> </property> </bean>
　　而在springboot中，好像就不是那么回事了，它变成是这样的，先继承一个 WebMvcConfigurationSupport
的基础组件，然后自定义各种配置如:
@Configuration public class SpringMVCConfig extends WebMvcConfigurationSupport
{ @Resourceprivate SessionInterceptor sessionInterceptor; @Override public void
addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(sessionInterceptor) .excludePathPatterns("/error"); }
/** * 添加自定义的Converters和Formatters. */ @Override public void
addFormatters(FormatterRegistry registry) { registry.addConverter(new
StringToDateConverter("yyyy-MM-dd HH:mm:ss")); } /** * Protected method for
plugging in a custom subclass of * {@link RequestMappingHandlerMapping}. *
@since 4.0 */ protected RequestMappingHandlerMapping
createRequestMappingHandlerMapping() {return new
RequestMappingHandlerMapping(); }/** * Protected method for plugging in a
custom subclass of * {@link RequestMappingHandlerAdapter}. * @since 4.3 */
protected RequestMappingHandlerAdapter createRequestMappingHandlerAdapter() {
return new RequestMappingHandlerAdapter(); } }
　　如上配置的依据是，在其父类 WebMvcConfigurationSupport 中，会创建一个
requestMappingHandlerMapping 的 bean, 而创建的过程，将方法暴露给了一个可供继承覆写的
createRequestMappingHandlerMapping 的方法，从而达到自定义 RequestMappingHandlerMapping
的目的。同理于 RequestMappingHandlerAdapter 。

　　而对于其他的各种自定义组件的接入，则按照文档说明来即可。对于一些通用的组件，一般都会有 xxx-starter
提供，从而可以避免n多的依赖配置，这也是springboot的一重要开发优势吧。毕竟，spring里面，你需要知道的太多了！

　　综上，咱们就可以规规矩矩地写业务代码了。总体的步骤就是：写配置变量到properties文件，使用 @Configuration 读取配置；实例化
bean 以供使用；

　　至于 xml 和 properties 的习惯问题，咱们就先不说了。

7. 最后，还有一个关键问题，打包部署？

　　springboot 往往是直接启动一个 main() 方法来运行的，和基于web容器的应用是不一样的。（内嵌容器）

　　在spring中，我们一般是通过maven打一个war包，然后部署到tomcat中。而在 springboot
中，则不一定要这么干了（甚至是不建议这么干），所以需要打一个 jar 包。

　　打jar包部署有两个问题：

　　　　1. jar包中的其他第三方依赖怎么办？

　　　　2. 部署维护交给谁？

　　一、针对第三方的jar包依赖问题，我们可以有两个解决方法：1. 将第三方的jar包打包进项目的jar包中； 2.
将依赖的jar包放抽离出来放到一个独立的lib库文件夹中，启动应用时再指定加载位置；各有优劣，一个是会导致jar包体积变大，一个是会导致开发维护困难（这是个大问题）。当然我们应该会选将其打包到一个jar中，一点体积是不会难倒我们的。3.
其实我觉得还有一种打包方式，就是将所有可能用到的class文件，全部解压出来打包到最终的jar包中，这样既做到体积小，又做到代码维护容易，但是可能会有些难度，因为你很难确定哪些class文件是不用的，所以一般也不敢排除（白干了）；

　　　　打jar包的依赖，可以参照如下插件配置：
<build> <resources> <resource> <directory>src/main/java</directory> </resource>
<resource> <directory>src/main/resources</directory> </resource> </resources> <
plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>
spring-boot-maven-plugin</artifactId> </plugin> <plugin> <groupId>
org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <
configuration> <archive> <manifest> <mainClass>com.xxx.service.StartApplication
</mainClass> <addClasspath>true</addClasspath> <classpathPrefix>lib/</
classpathPrefix> </manifest> </archive> <classesDirectory> </classesDirectory>
</configuration> </plugin> </plugins> </build>
　　注意：错误的配置可能导致依赖包嵌入有问题，或者切换环境不成功！

　　二、针对部署维护的问题，则依赖于你想运行的环境，如果你想使用原来的 tomcat
这种web容器运行服务，则无需另外担心维护问题，因为tomcat已经有了这些设备。而如果你使用jar包运行，则需要自行编写维护脚本了，其实功能也不外乎几个：

　　　　1. 启动；

　　　　2. 停止；

　　　　3. 查看状态；

　　　　4. springboot 需要的功能，就是支持动态修改配置属性，从而使测试环境与生产环境隔离；
#!/bin/sh ## project info SERVICE_DIR=/www/xxx SERVICE_NAME=myproject-1.0.0-
SNAPSHOT SPRING_PROFILES_ACTIVE=prod ## java env JAVA_HOME=/usr/java/jdk1.8
.0_101 pidfile="/opt/springboot/xxx.pid" JAVA_OPTS="$JAVA_OPTS -server -Xms512m
-Xmx2048m -Dfile.encoding=UTF-8 -Xloggc:/opt/springboot/logs/xxx_gc.log
-XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/opt/springboot/logs/" case "$1" in start) pid=`ps -ef | grep -
w "${SERVICE_NAME}" | grep -w "java"| grep -v "grep" | awk '{print $2}'` if [ "
${pid}" = "" ]; then if [ "$2" != "" ]; then SPRING_PROFILES_ACTIVE=$2 fi echo "
- Starting ${SERVICE_NAME} ..." echo " - Using JAVA_HOME: $JAVA_HOME ..." echo
" - Using Environment: spring.profiles.active=${SPRING_PROFILES_ACTIVE}" exec
nohup ${JAVA_HOME}/bin/java ${JAVA_OPTS} -jar
${SERVICE_DIR}/${SERVICE_NAME}\.jar
--spring.profiles.active=${SPRING_PROFILES_ACTIVE} >/dev/null 2>&1 & echo "$!" >
${pidfile};echo " - Congraduations!!! Started project
[${SERVICE_DIR}/${SERVICE_NAME}.jar] success, pid=$! ." else echo "- Oops!!!
${SERVICE_NAME} is alreaddy started @pid=${pid}, kill it ?" fi ;; stop) pid=`ps
-ef |grep -w "${SERVICE_NAME}" | grep -w "java" | grep -v "grep" | awk '{print
$2}'` rm -rf ${pidfile}; if [ "${pid}" = "" ]; then echo " - ${SERVICE_NAME} is
Already stopped." else echo " - Stopping ${SERVICE_NAME} by kill -15 ${pid} ..."
;kill -15 ${pid} sleep 1 pid2=`ps -ef | grep -w "${SERVICE_NAME}" | grep -w "
java" | grep -v "grep" | awk '{print $2}'` if [ "${pid2}" = "" ]; then echo " -
${SERVICE_NAME} stopped success !!!" else kill -9 ${pid2} echo " - Stop Failed!
${SERVICE_NAME} stop error, force kill ${pid2} !!!" fi fi ;; restart) $0 stop
sleep 1 $0 start $2 ;; status) pid=`ps -ef | grep -w "${SERVICE_NAME}" | grep -w
"java" | grep -v "grep" | awk '{print $2}'`; if [ "${pid}" = "" ]; then echo "
- Oops!!! ${SERVICE_NAME} is Already stopped." else # echo -e " -
${SERVICE_NAME} is ruuning, \033[36m pid=${pid} \033[0m ."; echo -e " -
${SERVICE_NAME} is ruuning, pid=${pid} ."; echo -e " - ${SERVICE_NAME} 's
server port is: `netstat -tunlp | grep"${pid}/" | awk '{print $1 " " $4;}'`.";
echo -e " - ${SERVICE_NAME} up info:`ps -eo pid,lstart,etime,cmd | grep
${SERVICE_NAME} | grep -v"grep" | awk '{print "startTime:"$2" "$3" "$4" "$5" "$6
", uptime:" $7}'`."; echo -e " - Current MEMORY Usage: `free -h | grep "Mem:" |
awk '{print"total: "$2", used: "$3".";}'`."; echo -e " - Current CPU Usage:
`top -bn 1 -i -c | sed -n '3p'`"; fi ;; *) echo " - Wrong command!!! Usage: $0
[start|stop|restart|status] [dev|test|prod]" ;; esac
　　运行方式如下：
springboot_xxx [start|stop|restart|status] [dev|test|prod]
　　以上，就是一些关于 springboot 使用的一些实践历程，对比 spring 和 springboot
的差异，总体来说，思路并没有变化，基本上只是习惯上的变化。

热门工具换一换