都说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
组件，去加载一个配置中心的值，从而实现替换各种连接的作用，使其脱离代码的硬编码；
<!-- spring的属性加载器，加载properties文件中的属性 --> <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 @Override public void contextLoaded(ConfigurableApplicationContext context) { for (ApplicationListener<?> listener : this.application.getListeners()) { if (listener instanceof 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}" /> <property name="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" /> <property name="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>
<!-- 添加会话拦截器 -->
<bean class="com.xxx.interceptor.SessionInterceptor">
</bean>
</list>
</property>
</bean>
而在springboot中，好像就不是那么回事了，它变成是这样的，先继承一个 WebMvcConfigurationSupport 的基础组件，然后自定义各种配置如:
@Configuration public class SpringMVCConfig extends WebMvcConfigurationSupport { @Resource private 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, 33[36m pid=${pid} 33[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 的差异，总体来说，思路并没有变化，基本上只是习惯上的变化。