現在搞Java還不會SpringBoot?看完這篇兩萬字筆記精髓就夠了

本文轉載自：現在搞Java還不會SpringBoot?看完這篇兩萬字筆記精髓就夠了

---

一、大綱

1. 瞭解Spring的發展
2. 掌握Spring的java配置方式
3. 學習Spring Boot
4. 使用Spring Boot來改造購物車系統

二、Spring的發展

2.1 Spring1.x 時代

在Spring1.x時代，都是通過xml文件配置bean，隨着項目的不斷擴大，需要將xml配置分放到不同的配置文件中，需要頻繁的在java類和xml配置文件中切換。

2.2 Spring2.x時代

隨着JDK 1.5帶來的註解支持，Spring2.x可以使用註解對Bean進行申明和注入，大大的減少了xml配置文件，同時也大大簡化了項目的開發。

那麼，問題來了，究竟是應該使用xml還是註解呢？

最佳實踐：

1. 應用的基本配置用xml，比如：數據源、資源文件等；
2. 業務開發用註解，比如：Service中注入bean等；

2.3 Spring3.x到Spring4.x

從Spring3.x開始提供了Java配置方式，使用Java配置方式可以更好的理解你配置的Bean，現在我們就處於這個時代，並且Spring4.x和Spring boot都推薦使用java配置的方式。

三、Spring的Java配置方式

Java配置是Spring4.x推薦的配置方式，可以完全替代xml配置。

3.1 @Configuration 和 @Bean

Spring的Java配置方式是通過 @Configuration 和 @Bean 這兩個註解實現的：

1. @Configuration 作用於類上，相當於一個xml配置文件；
2. @Bean 作用於方法上，相當於xml配置中的；

3.2 示例

該示例演示了通過Java配置的方式進行配置Spring，並且實現了Spring IOC功能。

3.2.1 創建工程以及導入依賴

<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>cn.itcast.springboot</groupId>
	<artifactId>itcast-springboot</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<packaging>war</packaging>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<!-- 連接池 -->
		<dependency>
			<groupId>com.jolbox</groupId>
			<artifactId>bonecp-spring</artifactId>
			<version>0.8.0.RELEASE</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<!-- 資源文件拷貝插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<configuration>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!-- java編譯插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
		</plugins>
		<pluginManagement>
			<plugins>
				<!-- 配置Tomcat插件 -->
				<plugin>
					<groupId>org.apache.tomcat.maven</groupId>
					<artifactId>tomcat7-maven-plugin</artifactId>
					<version>2.2</version>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
</project>

3.2.2 編寫User對象

public class User {
	private String username;
	private String password;
	private Integer age;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
}

3.2.3 編寫UserDAO 用於模擬與數據庫的交互

public class UserDAO {
	public List<User> queryUserList(){
		List<User> result = new ArrayList<User>();
		// 模擬數據庫的查詢
		for (int i = 0; i < 10; i++) {
			User user = new User();
			user.setUsername("username_" + i);
			user.setPassword("password_" + i);
			user.setAge(i + 1);
			result.add(user);
		}
		return result;
	}
}

3.2.4 編寫UserService 用於實現User數據操作業務邏輯

@Service
public class UserService {
	@Autowired // 注入Spring容器中的bean對象
	private UserDAO userDAO;
	public List<User> queryUserList() {
		// 調用userDAO中的方法進行查詢
		return this.userDAO.queryUserList();
	}
}

3.2.5 編寫SpringConfig 用於實例化Spring容器

@Configuration //通過該註解來表明該類是一個Spring的配置，相當於一個xml文件
@ComponentScan(basePackages = "cn.itcast.springboot.javaconfig") //配置掃描包
public class SpringConfig {
	@Bean // 通過該註解來表明是一個Bean對象，相當於xml中的<bean>
	public UserDAO getUserDAO(){
		return new UserDAO();
		// 直接new對象做演示
	}
}

3.2.6 編寫測試方法 用於啓動Spring容器

public class Main {
	public static void main(String[] args) {
		// 通過Java配置來實例化Spring容器
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
		// 在Spring容器中獲取Bean對象
		UserService userService = context.getBean(UserService.class);
		// 調用對象中的方法
		List<User> list = userService.queryUserList();
		for (User user : list) {
			System.out.println(user.getUsername() + ", " + user.getPassword() + ", " + user.getPassword());
		}
		// 銷燬該容器
		context.destroy();
	}
}

3.2.7 測試效果

3.2.8 小結

從以上的示例中可以看出，使用Java代碼就完美的替代xml配置文件，並且結構更加的清晰。

3.3 實戰

3.3.1 讀取外部的資源配置文件

通過@PropertySource可以指定讀取的配置文件，通過@Value註解獲取值，具體用法：

@Configuration //通過該註解來表明該類是一個Spring的配置，相當於一個xml文件
@ComponentScan(basePackages = "cn.itcast.springboot.javaconfig") //配置掃描包
@PropertySource(value= {"classpath:jdbc.properties"})
public class SpringConfig {
	@Value("${jdbc.url}")
	    private String jdbcUrl;
	@Bean // 通過該註解來表明是一個Bean對象，相當於xml中的<bean>
	public UserDAO getUserDAO(){
		return new UserDAO();
		// 直接new對象做演示
	}
}

思考：

①. 如何配置多個配置文件？

②. 如果配置的配置文件不存在會怎麼樣？

3.3.2 配置數據庫連接池

導入依賴：

<!-- 連接池 -->
		<dependency>
			<groupId>com.jolbox</groupId>
			<artifactId>bonecp-spring</artifactId>
			<version>0.8.0.RELEASE</version>
		</dependency>

之前的Spring xml配置：

<!-- 定義數據源 -->
	<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
		destroy-method="close">
		<!-- 數據庫驅動 -->
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<!-- 相應驅動的jdbcUrl -->
		<property name="jdbcUrl" value="${jdbc.url}" />
		<!-- 數據庫的用戶名 -->
		<property name="username" value="${jdbc.username}" />
		<!-- 數據庫的密碼 -->
		<property name="password" value="${jdbc.password}" />
		<!-- 檢查數據庫連接池中空閒連接的間隔時間，單位是分，默認值：240，如果要取消則設置爲0 -->
		<property name="idleConnectionTestPeriod" value="60" />
		<!-- 連接池中未使用的鏈接最大存活時間，單位是分，默認值：60，如果要永遠存活設置爲0 -->
		<property name="idleMaxAge" value="30" />
		<!-- 每個分區最大的連接數 -->
		<!-- 
			判斷依據：請求併發數
		 -->
		<property name="maxConnectionsPerPartition" value="100" />
		<!-- 每個分區最小的連接數 -->
		<property name="minConnectionsPerPartition" value="5" />
	</bean>

參考xml配置改造成java配置方式：

@Value("${jdbc.url}")
    private String jdbcUrl;
@Value("${jdbc.driverClassName}")
    private String jdbcDriverClassName;
@Value("${jdbc.username}")
    private String jdbcUsername;
@Value("${jdbc.password}")
    private String jdbcPassword;
@Bean(destroyMethod = "close")
    public DataSource dataSource() {
	BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
	// 數據庫驅動
	boneCPDataSource.setDriverClass(jdbcDriverClassName);
	// 相應驅動的jdbcUrl
	boneCPDataSource.setJdbcUrl(jdbcUrl);
	// 數據庫的用戶名
	boneCPDataSource.setUsername(jdbcUsername);
	// 數據庫的密碼
	boneCPDataSource.setPassword(jdbcUsername);
	// 檢查數據庫連接池中空閒連接的間隔時間，單位是分，默認值：240，如果要取消則設置爲0
	boneCPDataSource.setIdleConnectionTestPeriodInMinutes(60);
	// 連接池中未使用的鏈接最大存活時間，單位是分，默認值：60，如果要永遠存活設置爲0
	boneCPDataSource.setIdleMaxAgeInMinutes(30);
	// 每個分區最大的連接數
	boneCPDataSource.setMaxConnectionsPerPartition(100);
	// 每個分區最小的連接數    
	boneCPDataSource.setMinConnectionsPerPartition(5);
	return boneCPDataSource;
}

思考： 如何使用該DataSource對象？

四、Spring Boot

4.1 什麼是Spring Boot

隨着動態語言的流行(Ruby、Groovy、 Scala、 Node.js)，Java 的開發顯得格外的笨重：繁多的配置、低下的開發效率、複雜的部署流程以及第三方技術集成難度大。

在上述環境下，Spring Boot應運而生。它使用“習慣優於配置”(項目中存在大量的配置，此外還內置一個習慣性的配置，讓你無須手動進行配置)的理念讓你的項目快速運行起來。使用SpringBoot很容易創建一個獨立運行(運行jar,內嵌Servlet容器)、準生產級別的基於Spring框架的項目，使用Spring Boot你可以不用或者只需要很少的Spring配置。

4.2 Spring Boot的優缺點

優點

• 快速構建項目;
• 對主流開發框架的無配置集成;
• 項目可獨立運行，無須外部依賴Servlet容器;
• 提供運行時的應用監控;
• 極大地提高了開發、部署效率;
• 與雲計算的天然集成。

缺點

• 書籍文檔較少且不夠深入，這是直接促使我寫這本書的原因;
• 如果你不認同Spring框架，這也許是它的缺點，但建議你一定要使用Spring框架。

4.3 快速入門

4.3.1 設置spring boot的parent

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

說明：Spring boot的項目必須要將parent設置爲spring boot的parent，該parent包含了大量默認的配置，大大簡化了我們的開發。

4.3.2 導入spring boot的web支持

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

4.3.3 添加Spring boot的插件

<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>

4.3.4 編寫第一個Spring Boot的應用

@Controller
@SpringBootApplication
@Configuration
public class HelloApplication {
	@RequestMapping("hello")
	    @ResponseBody
	    public String hello(){
		return "hello world！";
	}
	public static void main(String[] args) {
		SpringApplication.run(HelloApplication.class, args);
	}
}

代碼說明：

1. @SpringBootApplication：Spring Boot項目的核心註解，主要目的是開啓自動配置。；
2. @Configuration：這是一個配置Spring的配置類；
3. @Controller：標明這是一個SpringMVC的Controller控制器；
4. main方法：在main方法中啓動一個應用，即：這個應用的入口；

4.3.5 啓動應用

在Spring Boot項目中，啓動的方式有兩種，一種是直接run Java Application另外一種是通過Spring Boot的Maven插件運行。

第一種：

第二種：

啓動效果：

看到如下信息就說明啓動成功了：

INFO 6188 --- [           main] c.i.springboot.demo.HelloApplication     : Started HelloApplication in 3.281 seconds (JVM running for 3.601)

4.3.6 測試

打開瀏覽器，輸入地址：

效果：

是不是很Easy?

4.4 Spring Boot的核心

4.4.41 入口類和@SpringBootApplication

Spring Boot的項目一般都會有*Application的入口類，入口類中會有main方法，這是一個標準的Java應用程序的入口方法。

@SpringBootApplication註解是Spring Boot的核心註解，它其實是一個組合註解：

該註解主要組合了以下註解：

①. @SpringBootConfiguration：這是Spring Boot項目的配置註解，這也是一個組合註解：

在Spring Boot項目中推薦使用@ SpringBootConfiguration替代@Configuration

②. @EnableAutoConfiguration：啓用自動配置，該註解會使Spring Boot根據項目中依賴的jar包自動配置項目的配置項：

a) 如：我們添加了spring-boot-starter-web的依賴，項目中也就會引入SpringMVC的依賴，Spring Boot就會自動配置tomcat和SpringMVC

③. @ComponentScan：默認掃描@SpringBootApplication所在類的同級目錄以及它的子目錄。

4.4.2 關閉自動配置

通過上述，我們得知，Spring Boot會根據項目中的jar包依賴，自動做出配置，Spring Boot支持的自動配置如下（非常多）：

如果我們不需要Spring Boot自動配置，想關閉某一項的自動配置，該如何設置呢？

比如：我們不想自動配置Redis，想手動配置。

當然了，其他的配置就類似了。

4.4.3 自定義Banner

啓動Spring Boot項目後會看到這樣的圖案：

這個圖片其實是可以自定義的：

①. 打開網站：http://patorjk.com/software/taag/#p=display&h=3&v=3&f=4Max&t=itcast%20Spring%20Boot

②. 拷貝生成的字符到一個文本文件中，並且將該文件命名爲banner.txt

③. 將banner.txt拷貝到項目的resources目錄中：

④. 重新啓動程序，查看效果：

好像沒有默認的好看啊！！！

如果不想看到任何的banner，也是可以將其關閉的：

4.4.4 全局配置文件

Spring Boot項目使用一個全局的配置文件application.properties或者是application.yml，在resources目錄下或者類路徑下的/config下，一般我們放到resources下。

①. 修改tomcat的端口爲8088

重新啓動應用，查看效果：

②. 修改進入DispatcherServlet的規則爲：*.html

測試：

4.4.5 Starter pom

Spring Boot爲我們提供了簡化企業級開發絕大多數場景的sarter pom，只要使用了應用場景所需要的sater pom，相關的技術配置將會消除，就可以得到Sprig Boot爲我們提供的自動配置的Bean。

4.4.6 Xml 配置文件

Spring Boot 提倡零配置，即無xml配置，但是在實際項目中，可能有一些特殊要求你必須使用xml配置，這時我們可以通過Spring提供的@ImportResource來加載xml配置，例如:

CImportResource({
	"clas spath: some-context. xml" ,"classpath: another-context. xml"
}
)

4.4.7 日誌

Spring Boot對各種日誌框架都做了支持，我們可以通過配置來修改默認的日誌的配置：

#設置日誌級別
logging.level.org.springframework=DEBUG

格式：

logging.level.*= # Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`

4.5 Spring Boot的自動配置的原理

Spring Boot在進行SpringApplication對象實例化時會加載META-INF/spring.factories文件，將該配置文件中的配置載入到Spring容器。

4.5.1 Maven下載源碼

通過 dependency:sources 該命令可以下載該項目中所有的依賴的包的源碼。

4.5.2 源碼分析

org.springframework.boot.SpringApplication：

org.springframework.core.io.support.SpringFactoriesLoader:

由此可見，讀取該配置文件來加載內容。

4.5.3 舉例：Redis的自動配置

從上述的配置中可以看出，org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration是Redis的自動配置。

內容：

4.5.4 條件註解

• @ConditionalOnBean:當容器裏有指定的Bean的條件下
• @ConditionalOnClass:當類路徑下有指定的類的條件下。
• @ConditionalOnExpression:
  基於SpEL表達式作爲判斷條件。
• @ConditionalOnJava:基於JVM版本作爲判斷條件。
• @ConditionalOnJndi:在JNDI存在的條件下查找指定的位置。
• @ConditionalOnMissingBean:當容器裏沒有指定Bean的情況下。
• @ConditionalOnMissingClass:當類路徑下沒有指定的類的條件下。
• @ConditionalOnNotWebApplication:當前項目不是Web項目的條件下。
• @ConditionalOnProperty:指定的屬性是否有指定的值。
• @ConditionalOnResource:類路徑是否有指定的值。
• @ConditionalOnSingleCandidate:當指定Bean 在容器中只有一個，或者雖然有多個但是指定首選的Bean。
• @ConditionalOn WebA pplication:當前項目是Web項目的條件下

五、Spring Boot的web開發

Web開發的自動配置類：org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration

5.1 自動配置的ViewResolver

視圖的配置mvcProperties對象中：

org.springframework.boot.autoconfigure.web.WebMvcProperties.View

5.2 自動配置靜態資源

5.2.1 進入規則爲 /

如果進入SpringMVC的規則爲/時，Spring Boot的默認靜態資源的路徑爲：
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

測試：

5.2.2. 進入規則爲*.xxx 或者 不指定靜態文件路徑時
將靜態資源放置到webapp下的static目錄中即可通過地址訪問：

測試：

5.3 自定義消息轉化器

自定義消息轉化器，只需要在@Configuration的類中添加消息轉化器的@bean加入到Spring容器，就會被Spring Boot自動加入到容器中。

@Bean
    public StringHttpMessageConverter stringHttpMessageConverter(){
	StringHttpMessageConverter converter  = new StringHttpMessageConverter(Charset.forName("UTF-8"));
	return converter;
}

默認配置：

5.4 自定義SpringMVC的配置

有些時候我們需要自已配置SpringMVC而不是採用默認，比如說增加一個攔截器，這個時候就得通過繼承WebMvcConfigurerAdapter然後重寫父類中的方法進行擴展。

import java.nio.charset.Charset;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration //申明這是一個配置
public class MySrpingMVCConfig extends WebMvcConfigurerAdapter{
	// 自定義攔截器
	@Override
	    public void addInterceptors(InterceptorRegistry registry) {
		HandlerInterceptor handlerInterceptor = new HandlerInterceptor() {
			@Override
			            public Boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			                    throws Exception {
				System.out.println("自定義攔截器............");
				return true;
			}
			@Override
			            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			                    ModelAndView modelAndView) throws Exception {
			}
			@Override
			            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			                    Exception ex) throws Exception {
			}
		}
		;
		registry.addInterceptor(handlerInterceptor).addPathPatterns("/**");
	}
	// 自定義消息轉化器的第二種方法
	@Override
	    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
		StringHttpMessageConverter converter  = new StringHttpMessageConverter(Charset.forName("UTF-8"));
		converters.add(converter);
	}
}

六、改造購物車系統

6.1 創建購物車的Spring Boot工程

6.2 導入依賴

<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
	</parent>
	<groupId>com.taotao.cart</groupId>
	<artifactId>taotao-cart-springboot</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<packaging>war</packaging>
	<dependencies>
		<dependency>
			<groupId>com.taotao.common</groupId>
			<artifactId>taotao-common</artifactId>
			<version>1.0.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>com.taotao.sso</groupId>
			<artifactId>taotao-sso-interface</artifactId>
			<version>1.0.0-SNAPSHOT</version>
		</dependency>
		<!-- 單元測試 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</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>
		<!-- 分頁助手 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>3.7.5</version>
		</dependency>
		<dependency>
			<groupId>com.github.jsqlparser</groupId>
			<artifactId>jsqlparser</artifactId>
			<version>0.9.1</version>
		</dependency>
		<!-- 通用Mapper -->
		<dependency>
			<groupId>com.github.abel533</groupId>
			<artifactId>mapper</artifactId>
			<version>2.3.4</version>
		</dependency>
		<!-- MySql -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
		</dependency>
		<!-- 連接池 -->
		<dependency>
			<groupId>com.jolbox</groupId>
			<artifactId>bonecp-spring</artifactId>
			<version>0.8.0.RELEASE</version>
		</dependency>
		<!-- httpclient -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
		</dependency>
		<!-- JSP相關 -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<!-- Apache工具組件 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.3.2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-io</artifactId>
			<version>1.3.2</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit</artifactId>
			<version>1.4.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<version>2.5.3</version>
			<exclusions>
				<exclusion>
					<!-- 排除傳遞spring依賴 -->
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.3.3</version>
		</dependency>
		<dependency>
			<groupId>com.github.sgroschupf</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.1</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!-- 資源文件拷貝插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<configuration>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!-- java編譯插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

6.3 將taotao-cart中的java代碼拷貝到taotao-car-springboot

拷貝完成後：

並且將properties文件也拷貝過來：

將頁面也拷貝過來：

6.3.1 編寫Spring配置類TaotaoApplication

6.3.2 設置tomcat端口

application.properties：

6.3.3 讀取外部的配置文件

@Configuration
@PropertySource(value = { "classpath:jdbc.properties", "classpath:env.properties",
        "classpath:httpclient.properties", "classpath:redis.properties", "classpath:rabbitmq.properties" }, ignoreResourceNotFound = true)
public class TaotaoApplication {
}

6.3.4 設置掃描包

6.3.5 定義數據源

@Value("${jdbc.url}")
    private String jdbcUrl;
@Value("${jdbc.driverClassName}")
    private String jdbcDriverClassName;
@Value("${jdbc.username}")
    private String jdbcUsername;
@Value("${jdbc.password}")
    private String jdbcPassword;
@Bean(destroyMethod = "close")
    public DataSource dataSource() {
	BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
	// 數據庫驅動
	boneCPDataSource.setDriverClass(jdbcDriverClassName);
	// 相應驅動的jdbcUrl
	boneCPDataSource.setJdbcUrl(jdbcUrl);
	// 數據庫的用戶名
	boneCPDataSource.setUsername(jdbcUsername);
	// 數據庫的密碼
	boneCPDataSource.setPassword(jdbcUsername);
	// 檢查數據庫連接池中空閒連接的間隔時間，單位是分，默認值：240，如果要取消則設置爲0
	boneCPDataSource.setIdleConnectionTestPeriodInMinutes(60);
	// 連接池中未使用的鏈接最大存活時間，單位是分，默認值：60，如果要永遠存活設置爲0
	boneCPDataSource.setIdleMaxAgeInMinutes(30);
	// 每個分區最大的連接數
	boneCPDataSource.setMaxConnectionsPerPartition(100);
	// 每個分區最小的連接數
	boneCPDataSource.setMinConnectionsPerPartition(5);
	return boneCPDataSource;
}

6.3.6 設置Mybatis和Spring Boot整合

Mybatis和Spring Boot的整合有兩種方式：

• 第一種：使用mybatis官方提供的Spring Boot整合包實現，地址：https://github.com/mybatis/spring-boot-starter
• 第二種：使用mybatis-spring整合的方式，也就是我們傳統的方式

這裏我們推薦使用第二種，因爲這樣我們可以很方便的控制Mybatis的各種配置。

首先，創建一個Mybatis的配置類：

代碼：

import javax.sql.DataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
@Configuration
public class MyBatisConfig {
	@Bean
	    @ConditionalOnMissingBean //當容器裏沒有指定的Bean的情況下創建該對象
	public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
		SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
		// 設置數據源
		sqlSessionFactoryBean.setDataSource(dataSource);
		// 設置mybatis的主配置文件
		ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
		Resource mybatisConfigXml = resolver.getResource("classpath:mybatis/mybatis-config.xml");
		sqlSessionFactoryBean.setConfigLocation(mybatisConfigXml);
		// 設置別名包
		sqlSessionFactoryBean.setTypeAliasesPackage("com.taotao.cart.pojo");
		return sqlSessionFactoryBean;
	}
}

然後，創建Mapper接口的掃描類MapperScannerConfig：

代碼：

import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@AutoConfigureAfter(MyBatisConfig.class) //保證在MyBatisConfig實例化之後再實例化該類
public class MapperScannerConfig {
	// mapper接口的掃描器
	@Bean
	    public MapperScannerConfigurer mapperScannerConfigurer() {
		MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
		mapperScannerConfigurer.setBasePackage("com.taotao.cart.mapper");
		return mapperScannerConfigurer;
	}
}

6.3.7 設置事務管理

在Spring Boot中推薦使用@Transactional註解來申明事務。

首先需要導入依賴：

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

當引入jdbc依賴之後，Spring Boot會自動默認分別注入DataSourceTransactionManager或JpaTransactionManager，所以我們不需要任何額外配置就可以用@Transactional註解進行事務的使用。

在Service中添加@Transactional註解：

@Transactional不僅可以註解在方法上，也可以註解在類上。當註解在類上的時候意味着此類的所有public方法都是開啓事務的。如果類級別和方法級別同時使用了@Transactional註解，則使用在類級別的註解會重載方法級別的註解。

6.3.8 設置Redis和Spring的整合

在Spring Boot中提供了RedisTempplate的操作，我們暫時不做學習，先按照我們之前的實現來完成。

代碼：

import java.util.ArrayList;
import java.util.List;
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 redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedisPool;
@Configuration
@PropertySource(value = "classpath:redis.properties")
public class RedisSpringConfig {
	@Value("${redis.maxTotal}")
	    private Integer redisMaxTotal;
	@Value("${redis.node1.host}")
	    private String redisNode1Host;
	@Value("${redis.node1.port}")
	    private Integer redisNode1Port;
	private JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(redisMaxTotal);
		return jedisPoolConfig;
	}
	@Bean
	    public ShardedJedisPool shardedJedisPool() {
		List<JedisShardInfo> jedisShardInfos = new ArrayList<JedisShardInfo>();
		jedisShardInfos.add(new JedisShardInfo(redisNode1Host, redisNode1Port));
		return new ShardedJedisPool(jedisPoolConfig(), jedisShardInfos);
	}
}

6.3.9 設置Httpclient和Spring的整合

import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Autowired;
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.context.annotation.Scope;
import com.taotao.common.httpclient.IdleConnectionEvictor;
@Configuration
@PropertySource(value = "classpath:httpclient.properties")
public class HttpclientSpringConfig {
	@Value("${http.maxTotal}")
	    private Integer httpMaxTotal;
	@Value("${http.defaultMaxPerRoute}")
	    private Integer httpDefaultMaxPerRoute;
	@Value("${http.connectTimeout}")
	    private Integer httpConnectTimeout;
	@Value("${http.connectionRequestTimeout}")
	    private Integer httpConnectionRequestTimeout;
	@Value("${http.socketTimeout}")
	    private Integer httpSocketTimeout;
	@Value("${http.staleConnectionCheckEnabled}")
	    private Boolean httpStaleConnectionCheckEnabled;
	@Autowired
	    private PoolingHttpClientConnectionManager manager;
	@Bean
	    public PoolingHttpClientConnectionManager poolingHttpClientConnectionManager() {
		PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
		// 最大連接數
		poolingHttpClientConnectionManager.setMaxTotal(httpMaxTotal);
		// 每個主機的最大併發數
		poolingHttpClientConnectionManager.setDefaultMaxPerRoute(httpDefaultMaxPerRoute);
		return poolingHttpClientConnectionManager;
	}
	// 定期關閉無效連接
	@Bean
	    public IdleConnectionEvictor idleConnectionEvictor() {
		return new IdleConnectionEvictor(manager);
	}
	// 定義Httpclient對
	@Bean
	    @Scope("prototype")
	    public CloseableHttpClient closeableHttpClient() {
		return HttpClients.custom().setConnectionManager(this.manager).build();
	}
	// 請求配置
	@Bean
	    public RequestConfig requestConfig() {
		return RequestConfig.custom().setConnectTimeout(httpConnectTimeout) // 創建連接的最長時間
		.setConnectionRequestTimeout(httpConnectionRequestTimeout) // 從連接池中獲取到連接的最長時間
		.setSocketTimeout(httpSocketTimeout) // 數據傳輸的最長時間
		.setStaleConnectionCheckEnabled(httpStaleConnectionCheckEnabled) // 提交請求前測試連接是否可用
		.build();
	}
}

6.3.10 設置RabbitMQ和Spring的整合

我們之前使用的Spring-Rabbit的xml方式，現在我們要改造成java方式，並且Spring Boot對RabbitMQ的使用做了自動配置，更加的簡化了我們的使用。

①. 在導入spring-boot-starter-amqp的依賴；

②. 在application.properties文件中配置RabbitMQ的連接信息

③. 編寫Rabbit的Spring配置類

import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMQSpringConfig {
	@Autowired
	    private ConnectionFactory connectionFactory;
	// 管理
	@Bean
	    public RabbitAdmin rabbitAdmin() {
		return new RabbitAdmin(connectionFactory);
	}
	// 聲明隊列
	@Bean
	    public Queue taotaoCartLoginQueue() {
		// 默認就是自動聲明的
		return new Queue("TAOTAO-CART-LOGIN-QUEUE", true);
	}
	// 聲明隊列
	@Bean
	    public Queue taotaoCartOrderSuccessQueue() {
		// 默認就是自動聲明的
		return new Queue("TAOTAO-CART-ORDER-SUCCESS-QUEUE", true);
	}
}

④. 設置監聽

6.3.11 設置SpringMVC的配置

原有配置：

具體實現：
視圖解析器配置：

自定義攔截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import com.taotao.cart.interceptors.UserLoginHandlerInterceptor;
@Configuration
public class SpringMVCConfig extends WebMvcConfigurerAdapter {
	@Override
	    public void addInterceptors(InterceptorRegistry registry) {
		// 判斷用戶是否登錄的攔截器
		registry.addInterceptor(new UserLoginHandlerInterceptor()).addPathPatterns("/cart/**");
	}
}

6.3.12 設置dubbo的配置

Dubbo目前只能使用xml配置的方式，所以我們需要保留xml，並且需要將該xml加入到現有的Spring容器中才能生效。

①. 將dubbo目錄以及下面的xml配置文件拷貝到taotao-cat-springboot中

②. 將dubbo的xml文件加入到spring容器

6.4 編寫入口類

編寫main方法：

6.4.1 啓動錯誤1

關鍵錯誤（丟失了web容器的工廠，也就是說我們並沒有把它作爲一個web應用來啓動）：

org.springframework.context.ApplicationContextException: Unable to start embedded container; nested exception is org.springframework.context.ApplicationContextException: Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean.

解決：

讓Spring Boot來自動選擇並且完成web的相關加載工作。

6.4.2 Slf4j日誌警告

提示我們當前的項目中slf4j引入了2個，導致了jar衝突。

解決：

①. 刪除自己引入到slf4j的依賴

②. 將taotao-common中傳遞的依賴排除掉

再次啓動，發現警告沒了：

6.4.3 解決jsp訪問404的問題

由於Spring boot使用的內嵌的tomcat，而內嵌的tamcat是不支持jsp頁面的，所有需要導入額外的包才能解決。

<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
			<scope>provided</scope>
		</dependency>

重新啓動進行測試：

6.4.4 攔截器中的UserService空指針異常

分析：由於添加攔截器時，直接對UserLoginHandlerInterceptor進行new操作，導致UserService無法注入，所以有空指針異常。

解決：

6.4.5 路徑問題

現在我們進入Servlet的路徑爲”/”，訪問*.html頁面沒問題，但是，訪問 /service/* 就會有問題，所以需要改一下js，將原有的/service/ 改爲 /

測試，功能一切ok。

七、發佈到獨立的tomcat中運行

在開發階段我們推薦使用內嵌的tomcat進行開發，因爲這樣會方便很多，但是到生成環境，我希望在獨立的tomcat容器中運行，因爲我們需要對tomcat做額外的優化，這時我們需要將工程打包成war包發進行發佈。

7.1 工程的打包方式爲war

7.2 將spring-boot-starter-tomcat的範圍設置爲provided

設置爲provided是在打包時會將該包排除，因爲要放到獨立的tomcat中運行，是不需要的。

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>

7.3 修改代碼，設置啓動配置

需要集成SpringBootServletInitializer，然後重寫configure，將Spring Boot的入口類設置進去。

7.4 打war包

打包成功：

7.5 部署到tomcat

解壓apache-tomcat-7.0.57.tar.gz，將war包解壓到webapps下的ROOT目錄中，啓動：

完美。

---

本文轉載自：現在搞Java還不會SpringBoot?看完這篇兩萬字筆記精髓就夠了