欢迎大家来到IT世界,在知识的湖畔探索吧!

一、大纲

了解Spring的发展
掌握Spring的java配置方式
学习Spring Boot
使用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还是注解呢？

最佳实践：

应用的基本配置用xml，比如：数据源、资源文件等；
业务开发用注解，比如：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 这两个注解实现的：

@Configuration 作用于类上，相当于一个xml配置文件；
@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>

欢迎大家来到IT世界,在知识的湖畔探索吧!

3.2.2 编写User对象

欢迎大家来到IT世界,在知识的湖畔探索吧!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数据操作业务逻辑

欢迎大家来到IT世界,在知识的湖畔探索吧!@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);
	}
}

代码说明：

@SpringBootApplication：Spring Boot项目的核心注解，主要目的是开启自动配置。；
@Configuration：这是一个配置Spring的配置类；
@Controller：标明这是一个SpringMVC的Controller控制器；
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 Spring Boot

②. 拷贝生成的字符到一个文本文件中，并且将该文件命名为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程序员，笔者最近整理了一些面试真题，思维导图，程序人生等PDF学习资料；
关注私信我”86″，即可获取！
希望读到这的您能点个小赞和关注下我，以后还会更新技术干货，谢谢您的支持！

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://itzsg.com/34516.html

云烟 2023年 4月 25日

你这文采，堪称现代李白

评论于 Servlet 数据库访问[通俗易懂]
样 2023年 4月 25日

博主有大厦之将倾而面不改色，狂澜于既倒而稳如泰山只能。

评论于 Servlet 数据库访问[通俗易懂]
样 2023年 4月 25日

博主好文采

评论于古天乐拍戏误伤眼球缝八针！而他第一时间却只想给粉丝道歉[通俗易懂]
样 2023年 4月 25日

干货干货

评论于 UG编程，钻孔攻丝，铣螺纹，干货知识[亲测有效]
云烟 2023年 4月 25日

人家是chatGPT 不是GBT

评论于程序开发中MySql、SQLServer、SQLite数据库的使用场景及性能评测

现在搞Java还不会SpringBoot?看完这篇两万字笔记精髓就够了

一、大纲

二、Spring的发展

三、Spring的Java配置方式

四、Spring Boot

五、Spring Boot的web开发

六、改造购物车系统

七、发布到独立的tomcat中运行

写在最后：

发表回复

联系我们YX

mu99908888

现在搞Java还不会SpringBoot?看完这篇两万字笔记精髓就够了

一、大纲

二、Spring的发展

三、Spring的Java配置方式

四、Spring Boot

五、Spring Boot的web开发

六、改造购物车系统

七、发布到独立的tomcat中运行

写在最后：

相关推荐

发表回复

联系我们YX

mu99908888