目录
- 1.1 第一章 Xml 和 JavaConfig
- 1.2 第二章 Spring Boot 入门
- 1.2.1 第一种方式:https://start.spring.io
- 1.2.2 第二种方式,使用 springboot 提供的初始化器, 使用的国内的地址
- 1.2.3 第三种方式 使用 maven 向导创建项目
- 1.2.4 Spring Boot 核心配置文件
- 1.2.5 Spring Boot 中使用 JSP
- 1.2.5.1 在 pom.xml 文件中配置以下依赖项
- 1.2.5.2 在 pom.xml 的 build 标签中要配置以下信息
- 1.2.5.3 在 application.properties 文件配置 Spring MVC 的视图展示为jsp,这里相当于 Spring MVC 的配置
- 1.2.5.4 在 com.bjpowernode.springboot.controller 包 下 创 建JspController 类,并编写代码
- 1.2.5.5 在 src/main 下创建一个 webapp 目录,然后在该目录下新建index.jsp 页面
- 1.2.5.6 在 jsp 中获取 Controller 传递过来的数据
- 1.2.5.7 重新运行 Application,通过浏览器访问测试
- 1.2.6 Spring Boot 中使用 ApplicationContext
- 1.2.7 CommandLineRunner 接口
1.1 第一章 Xml 和 JavaConfig
Spring 使用 Xml 作为容器配置文件, 在 3.0 以后加入了 JavaConfig. 使用 java 类做配置文件使用。
1.1.1 什么是 JavaConfig
JavaConfig: 是 Spring 提供的使用 java 类配置容器。 配置 Spring IOC 容器的纯 Java 方法。
优点:
1.可以使用面像对象的方式, 一个配置类可以继承配置类,可以重写方法
2.避免繁琐的 xml 配置
1.1.2 Xml 配置容器
创建 001-pre-boot 项目
pom.xml
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编译插件 -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<!-- 插件的版本 -->
<version>3.5.1</version>
<!-- 编译级别 -->
<configuration>
<source>1.8</source>
<target>1.8</target>
<!-- 编码格式 -->
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
创建数据类 Student
package com.bjpowernode.vo
public class Student {
private Integer id;
private String name;
private Integer age;
// set | get
}
resources 目录下创建 Spring 的配置文件 applicationContext.xml
<bean id="myStudent" class="com.bjpowernode.vo.Student">
<property name="id" value="1001" />
<property name="name" value="李强国" />
<property name="age" value="20" />
</bean>
单元测试:
@Test
public void test01(){
String config="applicationContext.xml";
ApplicationContext ctx = new
ClassPathXmlApplicationContext(config);
Student student = (Student) ctx.getBean("myStudent");
System.out.println("student="+student);
}
1.1.3 JavaConfig 配置容器
JavaConfig 主要使用的注解
@Configuration:放在类的上面, 这个类相当于 xml 配置文件,可以在其中声明 bean
@Bean:放在方法的上面, 方法的返回值是对象类型, 这个对象注入到 spring ioc 容器
创建配置类(等同于 xml 配置文件)
package com.bjpowernode.config;
import com.bjpowernode.vo.Persion;
import com.bjpowernode.vo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import java.util.Date;
/**
* @Configuration:表示当前类是 xml 配置文件的作用
* 在这个类中有很多方法, 方法的返回值是对象。
* 在这个方法的上面加入@Bean, 表示方法返回值的对象放入到容器中。
* @Bean == <bean></bean>
*/
@Configuration
public class SpringConfig {
/**
* 定义方法, 方法的返回值是对象。
* @Bean:表示把对象注入到容器中。
* 位置: 方法的上面
* @Bean 没有使用属性,默认对象名称是方法名
*/
@Bean
public Student createStudent(){
Student student = new Student();
student.setId(1002);
student.setName("周仓");
student.setAge(29);
return student;
}
// name :指定对象的名称
@Bean(name = "myStudent2")
public Student makeStudent(){
Student student = new Student();
student.setId(1003);
student.setName("诸葛亮");
student.setAge(30);
return student;
}
@Bean
public Date myDate(){
return new Date();
}
}
}
测试方法:
//使用 JavaConfig
@Test
public void test02(){
//没有 xml 配置文件,使用 java 类代替 xml 配置文件 的作用
ApplicationContext ctx = new
AnnotationConfigApplicationContext(SpringConfig.class);
Student student = (Student) ctx.getBean("createStudent");
System.out.println("student==="+student);
}
@Test
public void test03(){
//没有 xml 配置文件,使用 java 类代替 xml 配置文件 的作用
ApplicationContext ctx = new
AnnotationConfigApplicationContext(SpringConfig.class);
Student student = (Student) ctx.getBean("myStudent2");
System.out.println("myStudent2==="+student);
Object myDate = ctx.getBean("myDate");
System.out.println("myDate = " + myDate);
}
1.1.4 @ImportResource
@ImportResource 是导入 xml 配置,等同于 xml 文件的 resources
创建数据类:
public class Cat {
private String cardId;
private String name;
private Integer age;
// set |get
}
创建配置文件 beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myCat" class="com.bjpowernode.vo.Cat">
<property name="cardId" value="XSET29001" />
<property name="name" value="tom 猫"/>
<property name="age" value="3" />
</bean>
</beans>
创建配置类:
@Configuration
@ImportResource(value =
{"classpath:beans.xml","classpath:applicationContext.xml"})
public class SystemConfig {
//使用@Bean 声明 bean
}
创建测试方法:
@Test
public void test04(){
//没有 xml 配置文件,使用 java 类代替 xml 配置文件 的作用
ApplicationContext ctx =
new AnnotationConfigApplicationContext(SystemConfig.class);
Cat cat = (Cat) ctx.getBean("myCat");
System.out.println("cat==="+cat);
}
1.1.5 @PropertyResource
@PropertyResource 是读取 properties 属性配置文件
在 resources 目录下创建 config.properties
tiger.name=东北老虎
tiger.age=6
创建数据类 Tiger
@Component("tiger")
public class Tiger {
@Value("${tiger.name}")
private String name;
@Value("${tiger.age}")
private Integer age;
@Override
public String toString() {
return "Tiger{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
修改 SystemConfig 文件
@Configuration
@PropertySource(value = "classpath:config.properties")
@ComponentScan(value = "com.bjpowernode.vo")
public class SystemConfig {
//使用@Bean 声明 bean
}
创建测试方法
@Test
public void test05(){
//没有 xml 配置文件,使用 java 类代替 xml 配置文件 的作用
ApplicationContext ctx =
new AnnotationConfigApplicationContext(SystemConfig.class);
Tiger tiger = (Tiger) ctx.getBean("tiger");
System.out.println("Tiger==="+tiger);
}
1.2 第二章 Spring Boot 入门
1.2.1 第一种方式:https://start.spring.io
使用 spring boot 提供的初始化器。 向导的方式,完成 spring boot 项目的创建: 使用方便。
1.2.1.1 创建项目步骤
step 1: 新建项目
step 2
step 3 选择依赖
step 4 : 最后创建项目,设置项目的目录位置
step 5: Spring Boot 项目目录结构
1.2.1.2 起步依赖
1.2.2 第二种方式,使用 springboot 提供的初始化器, 使用的国内的地址
国内地址: https://start.springboot.io
创建项目的步骤同上
1.2.3 第三种方式 使用 maven 向导创建项目
创建一个普通 maven 项目
添加 gav
点击 finish 创建,完成项目创建。
修改项目的目录
添加 Spring Boot 依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
创建启动类:加入@SpringBootApplication 注解
package com.bjpowernode;
@SpringBootApplication
public class MySpringBootMain {
public static void main(String[] args) {
SpringApplication.run(MySpringBootMain.class,args);
}
}
1.2.3.1 入门案例
1.2.3.2 入门案例分析
1.2.3.3 重要注解
@SpringBootApplication : @SpringBootApplication 是 一 个 复 合 注 解 , 是 由@SpringBootConfiguration, @EnableAutoConfiguration ,@ComponentScan 联合在一起组成的。
@SpringBootConfiguration : 就 是 @Configuration 这 个 注 解 的 功 能 , 使 用@SpringBootConfiguration 这个注解的类就是配置文件的作用。
@EnableAutoConfiguration:开启自动配置, 把一些对象加入到 spring 容器中。
@ComponentScan:组件扫描器, 扫描注解,根据注解的功能,创建 java bean,给属性赋值等。组件扫描器默认扫描的是 @ComponentScan 注解所在的类, 类所在的包和子包。
1.2.4 Spring Boot 核心配置文件
Spring Boot 的核心配置文件用于配置 Spring Boot 程序,名字必须以 application 开始
1.2.4.1 .properties 文件(默认采用该文件)
在 002-springboot-springmvc 项目基础上,进行修改
项目名称:003-springboot-port-context-path
通过修改 application.properties 配置文件,在修改默认 tomcat 端口号及项目上下文件根键值对的 properties 属性文件配置方式
#设置访问端口号
server.port=9092
#应用的 contextpath
server.servlet.context-path=/boot
启动应用, 在浏览器访问 http://localhost:9092/boot/
1.2.4.2 .yml 文件
项目名称:005-springboot-yml,在之前项目基础之上
yml 是一种 yaml 格式的配置文件,主要采用一定的空格、换行等格式排版进行配置。
yaml 是一种直观的能够被计算机识别的的数据序列化格式,容易被人类阅读,yaml 类似于 xml,但是语法比 xml 简洁很多,值与前面的冒号配置项必须要有一个空格, yml 缀也可以使用 yaml 后缀
server:
port: 9091
servlet:
context-path: /boot
注意 : 当两种格式配置文件同时存在 ,在 SpringBoot2.4 开始, 使用的是 yml 配置文件.
修改配置名称都为 application。
重新运行 Application ,查看启动的端口及上下文根
推荐使用 yml 格式配置文件
1.2.4.3 多环境配置
在实际开发的过程中,我们的项目会经历很多的阶段(开发->测试->上线),每个阶段的配置也会不同,例如:端口、上下文根、数据库等,那么这个时候为了方便在不同的环境之间切换,SpringBoot 提供了多环境配置,具体步骤如下
项目名称:006-springboot-multi-environment为每个环境创建一个配置文件,命名必须以 application-环境标识.properties|yml
application.properties
#指定使用的环境文件
#spring.profiles.active=dev
spring.profiles.active=test
application-dev.properties
#开发环境的信息
server.port=9091
server.servlet.context-path=/mydev
application-product.properties
server.port=9093
server.servlet.context-path=/myprod
application-test.properties
#开发环境的信息
server.port=9091
server.servlet.context-path=/mydev
1.2.4.4 Spring Boot 自定义配置
SpringBoot 的核心配置文件中,除了使用内置的配置项之外,我们还可以在自定义配置,然后采用如下注解去读取配置的属性值
1.2.4.4.1 @Value 注解
@Value(“${key}”) , key 来自 application.properties(yml)
application.properties:添加两个自定义配置项 school.name 和
school.website。在 IDEA 中可以看到这两个属性不能被 SpringBoot 识别,背景是桔色的
server.port=9090
server.servlet.context-path=/myboot
school.name=动力节点
school.address=北京大兴区
school.website=www.bjpowernode.com
site=www.bjpowernode.com
读取配置文件数据
@Controller
public class HelloController {
@Value("${server.port}")
private String port;
@Value("${school.name}")
private String name;
@Value("${site}")
private String site;
@RequestMapping("/hello")
@ResponseBody
public String doHello(){
return "hello, port:" + port + "学校:"+name+",网站:"+site;
}
}
启动应用 Application , 访问浏览器
1.2.4.4.2 @ConfigurationProperties
项目名称:008-springboot-custom-configuration
将整个文件映射成一个对象,用于自定义配置项比较多的情况
案例演示
在 com.bjpowernode.springboot.config 包下创建 SchoolInfo 类,并为该 类加上Component 和 ConfigurationProperties 注解,prefix 可以不指定,如果不指定,那么会去配置文件中寻找与该类的属性名一致的配置,prefix 的作用可以区分同名配置
@Component
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {
private String name;
private String address;
private String website;
// set | get 方法
}
创建 SchoolController
@Controller
public class SchoolController {
@Resource
private SchoolInfo schoolInfo;
@RequestMapping("/myschool")
@ResponseBody
public String doSchool(){
return "学校信息:"+schoolInfo.toString();
}
}
执行 Application , 访问浏览器查看数据
1.2.4.4.3 警告解决
➢ 在 SchoolInfo 类中使用了 ConfigurationProperties 注解,IDEA 会出现一个警告,不影响程序的执行
➢ 点击 open documentnation 跳转到网页,在网页中提示需要加一个依赖,我们将这个依赖拷贝,粘贴到 pom.xml 文件中
<!--解决使用@ConfigurationProperties 注解出现警告问题-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
1.2.4.4.4 中文乱码
如果在 SpringBoot 核心配置文件中有中文信息,会出现乱码:
◼ 一般在配置文件中,不建议出现中文(注释除外)
◼ 如果有,可以先转化为 ASCII 码
1.2.4.4.5 提示
大家如果是从其它地方拷贝的配置文件,一定要将里面的空格删干净
1.2.5 Spring Boot 中使用 JSP
1.2.5.1 在 pom.xml 文件中配置以下依赖项
<!--引入 Spring Boot 内嵌的 Tomcat 对 JSP 的解析包,不加解析不
了 jsp 页面-->
<!--如果只是使用 JSP 页面,可以只添加该依赖-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--如果要使用 servlet 必须添加该以下两个依赖-->
<!-- servlet 依赖的 jar 包-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- jsp 依赖 jar 包-->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>
<!--如果使用 JSTL 必须添加该依赖-->
<!--jstl 标签依赖的 jar 包 start-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
1.2.5.2 在 pom.xml 的 build 标签中要配置以下信息
SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问,否则访问不到。其实官方已经更建议使用模板技术(后面会讲模板技术)
<!—
SpringBoot 要求 jsp 文件必须编译到指定的
META-INF/resources 目录下才能访问,否则访问不到。
其它官方已经建议使用模版技术(后面会课程会单独讲解模版技
术)
-->
<resources>
<resource>
<!--源文件位置-->
<directory>src/main/webapp</directory>
<!--指定编译到META-INF/resource,该目录不能随便写-->
<targetPath>META-INF/resources</targetPath>
<!--指定要把哪些文件编译进去,**表示 webapp 目录及子
目录,*.*表示所有文件-->
<includes>
<include>**/*.*</include>
</includes>
</resource>
</resources>
1.2.5.3 在 application.properties 文件配置 Spring MVC 的视图展示为jsp,这里相当于 Spring MVC 的配置
#配置 SpringMVC 的视图解析器
#其中:/相当于 src/main/webapp 目录
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
集成完毕之后,剩下的步骤和我们使用 Spring MVC 一样
1.2.5.4 在 com.bjpowernode.springboot.controller 包 下 创 建JspController 类,并编写代码
@Controller
public class SpringBootController {
@RequestMapping(value = "/springBoot/jsp")
public String jsp(Model model) {
model.addAttribute("data","SpringBoot 前端使用 JSP 页面!");
return "index";
}
}
1.2.5.5 在 src/main 下创建一个 webapp 目录,然后在该目录下新建index.jsp 页面
如果在webapp目录下右键,没有创建jsp的选项,可以在Project Structure中指定webapp为 Web Resource Directory
1.2.5.6 在 jsp 中获取 Controller 传递过来的数据
1.2.5.7 重新运行 Application,通过浏览器访问测试
1.2.6 Spring Boot 中使用 ApplicationContext
在 main 方法中 SpringApplication.run()方法获取返回的 Spring 容器对象,再获取业务 bean进行调用.
创建 Spring Boot 项目:010-springboot-container
指定项目的 gav 和版本等信息
选择依赖:
创建一个接口 UserService 和他的实现类
创建启动类, main 方法中获取容器对象
1.2.7 CommandLineRunner 接口
开发中可能会有这样的情景。需要在容器启动后执行一些内容。比如读取配置文件,数据库连接之类的。SpringBoot 给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为 CommandLineRunner 和 ApplicationRunner。他们的执行时机为容器启动完成的时候。这两个接口中有一个 run 方法,我们只需要实现这个方法即可。这两个接口的不同之处
在于: ApplicationRunner 中 run 方 法 的 参 数 为 ApplicationArguments , 而CommandLineRunner接口中 run 方法的参数为 String 数组
创建 Spring Boot 项目,不用选依赖,或者修改 010-springboot-container
创建 SomeService 接口和实现类,定义 sayHello()方法
public interface SomeService {
void sayHello(String name);
}
@Service("someService")
public class SomeServiceImpl implements SomeService {
@Override
public void sayHello(String name) {
System.out.println("欢迎:"+name);
}
}
实现 CommandLineRunner 接口
@SpringBootApplication
public class Application implements CommandLineRunner {
public static void main(String[] args) {
//run 方法返回值是容器对象
//1.创建容器对象
ConfigurableApplicationContext ctx =
SpringApplication.run(Application.class, args);
SomeService service = (SomeService) ctx.getBean("someService");
service.sayHello("李四");
}
@Override
public void run(String... args) throws Exception {
//2. 容器对象创建好,执行 run
System.out.println("输出, 在容器对象创建好后执行的代码");
}
}
运行主类,查看输出结果