自己的springboot的基本原理知识点梳理

最新推荐文章于 2025-07-17 21:01:39 发布

一颗知足的心

最新推荐文章于 2025-07-17 21:01:39 发布

阅读量1.4k

点赞数 1

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/StreamlineWq/article/details/86562196

本文深入探讨SpringBoot基础知识，包括Java配置替代XML，自定义拦截器，以及如何使用SpringBoot改造购物车项目，实现自动配置，事务管理，和SpringMVC配置。

springboot知识点复习梳理

导读：springboot相比于ssm来说，就是将其中复杂的xml文件配置转化成了java配置。
一、我们先来一个简单的案例演示，通过Java配置的方式进行配置Spring，并且实现了Spring IOC功能。
1.首先是pom文件的依赖导入

<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>

2.创建一个pojo对象user package cn.itcast.springboot.javaconfig; public class User { private String username; private String password; private Integer age; . . . } 3.编写UserDao 模拟实现一个查询数据库方法 package cn.itcast.springboot.javaconfig;

import java.util.ArrayList;
import java.util.List;

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;
}

}

4.编写Service用于实现User数据操作业务逻辑
package cn.itcast.springboot.javaconfig;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service //service注解，为后面的扫描做准备
public class UserService {
@Autowired // 注入Spring容器中的bean对象
private UserDAO userDAO;

public List<User> queryUserList() {
    // 调用userDAO中的方法进行查询
    return this.userDAO.queryUserList();
}

}
5.编写SpringConfig 用于实例化Spring容器
@Configuration //通过该注解来表明该类是一个Spring的配置，相当于一个xml文件
@ComponentScan(basePackages = “cn.itcast.springboot.javaconfig”) //配置扫描包，用于扫描service
public class SpringConfig {

@Bean // 通过该注解来表明是一个Bean对象，相当于xml中的<bean>
public UserDAO getUserDAO(){
    return new UserDAO(); // 直接new对象做演示
}

}
6.编写测试方法用于启动Spring容器
（1）本步重点： AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
通过此上下文的类来读取刚才实例化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();
    }

}

二、小案例实战，用springboot的知识来取代ssm中的xml配置文件
1.创建一个类HelloApplication
（1）此类有三个注解：Controller SpringBootApplication Configuration
第一个注解表明此类是个控制层的类，可以用来处理逻辑；
第二个注解是核心，所有的springboot的启动类都需要这个注解；
第三个注解又表明此类是个xml文件。

@Controller
@SpringBootApplication
@Configuration

public class HelloApplication {

（2）
1： @RequestMapping(value=“hello”)
访问时的路径映射
2：@ResponseBody
将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据

@RequestMapping(value="hello")
@ResponseBody
public String hello(){
    return "hello world！传智播客";
}

（3）@Bean
这一部分的引用Bean注解，相当于xml文件里面的一个对象，来知名当前数据的编码方式

@Bean
public StringHttpMessageConverter stringHttpMessageConverter(){
    StringHttpMessageConverter converter  = new StringHttpMessageConverter(Charset.forName("ISO-8859-1"));
    return converter;

}
（4）main方法
在每一个springboot的启动类里面一定要有一个main方法，用来启动想要启动的类
SpringApplication是前面注解的方法，调用当中的run方法，来启动配置java类。

public static void main(String[] args) {
	SpringApplication.run(HelloApplication.class, args);
}

}
2.自定义拦截器
创建一个类来继承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);
}

}

三、springboot实现改造购物车。
1.导入依赖
（1）最为重要的

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

在springboot的依赖中，父依赖必须要为springboot的父依赖，不能用我们自己定义的父依赖，里面包含了大量的配置。
（2）重要的

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

这是编写web的时候要导入的springboot依赖。

2.创建java类代替xml文件
1.替换applicationContext-dao.xml
（1）创建TaotaoApplication类完成对数据库连接访问
解释：1.@PropertySource注解是用来读取properties文件的，
ignoreResourceNotFound = true 如果properties文件没找到依旧执行，不会报错。
2.@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中，像@Controller，@Service，@Repository，@Component等注解都在扫描范围内
3.
@Value(" ${jdbc.url}") private String jdbcUrl; 定义一个string类型的变量jdbcUrl，将其值赋值为$ {jdbc.url}，因为前面的扫描已经读取了jdbc.properties里面的内容

@Configuration
@PropertySource(value={ "classpath:jdbc.properties", "classpath:env.properties","classpath:httpclient.properties"}, ignoreResourceNotFound = true)
@ComponentScan(basePackages="com.taotao")
public class TaotaoApplication {
	
	@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;

    }

这是以前xml文件的连接池

	<!-- 数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		destroy-method="close">
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="maxActive" value="10" />
		<property name="minIdle" value="5" />
	</bean>

2.创建一个类MyBatisConfig来代替mybatisxml配置
解释： @ConditionalOnMissingBean 这个注解的意思就是如果当前运行中没有这个@Bean类那么就创建，如果有，则无所谓

@Configuration
public class MyBatisConfig {

	@Bean
	@ConditionalOnMissingBean
	public SqlSessionFactoryBean sqlSessionFactoryBean(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;
	}
}

这是以前xml文件的配置

<!-- 让spring管理sqlsessionfactory 使用mybatis和spring整合包中的 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 数据库连接池 -->
		<property name="dataSource" ref="dataSource" />
		<!-- 加载mybatis的全局配置文件 -->
		<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
	</bean>

3.创建一个类MapperScannerConfig代替以前xml配置中的mapper扫描

@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;
    }
}

这是以前xml文件的配置

	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.taotao.mapper" />
	</bean>

4.全局配置文件
创建一个文件application.propertirs
（1）server.port:8086 //指定当前运行的端口号

（2）server.servlet-path:/ 修改进入DispatcherServlet的规则为：/

（3）如果进入SpringMVC的规则为/时，Spring Boot的默认静态资源的路径为：
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

（4）进入规则为*.xxx 或者不指定静态文件路径时
将静态资源放置到webapp下的static目录中即可通过地址访问

5.Spring Boot的自动配置的原理
Spring Boot在进行SpringApplication对象实例化时会加载META-INF/spring.factories文件，将该配置文件中的配置载入到Spring容器。

6.设置事务管理
在Spring Boot中推荐使用@Transactional注解来申明事务。

首先需要导入依赖：

org.springframework.boot
spring-boot-starter-jdbc

当引入jdbc依赖之后，Spring Boot会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager，所以我们不需要任何额外配置就可以用@Transactional注解进行事务的使用。

在Service中添加@Transactional注解：

7.设置SpringMVC的配置

在这里插入图片描述

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冲突。

解决：
1、删除自己引入到slf4j的依赖
在这里插入图片描述

2、将taotao-common中传递的依赖排除掉

在这里插入图片描述
再次启动，发现警告没了：

6.4.3. 解决jsp访问404的问题
由于Spring boot使用的内嵌的tomcat，而内嵌的tamcat是不支持jsp页面的，所有需要导入额外的包才能解决。

org.apache.tomcat.embed tomcat-embed-jasper provided

6.4.4. 拦截器中的UserService空指针异常
分析：由于添加拦截器时，直接对UserLoginHandlerInterceptor进行new操作，导致UserService无法注入，所以有空指针异常。

解决：
在这里插入图片描述

发布到独立的tomcat中运行
在开发阶段我们推荐使用内嵌的tomcat进行开发，因为这样会方便很多，但是到生成环境，我希望在独立的tomcat容器中运行，因为我们需要对tomcat做额外的优化，这时我们需要将工程打包成war包发进行发布。
7.1. 工程的打包方式为war

7.2. 将spring-boot-starter-tomcat的范围设置为provided
设置为provided是在打包时会将该包排除，因为要放到独立的tomcat中运行，是不需要的。

org.springframework.boot spring-boot-starter-tomcat provided 7.3. 修改代码，设置启动配置需要集成SpringBootServletInitializer，然后重写configure，将Spring Boot的入口类设置进去。 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190120165856336.?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N0cmVhbWxpbmVXcQ==,size_16,color_FFFFFF,t_70) 7.4. 打war包 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2019012016590463.?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N0cmVhbWxpbmVXcQ==,size_16,color_FFFFFF,t_70)

打包成功：
在这里插入图片描述
7.5. 部署到tomcat
解压apache-tomcat-7.0.57.tar.gz，将war包解压到webapps下的ROOT目录中，启动：