Spring Boot学习笔记

Spring Boot学习笔记

Spring的体系结构

image-20210318193325775

Spring基础

Spring开发环境搭建

graph LR
A[SpringBoot]--IDE-->B[Eclipse]
B-->C[JDK]
B-->D[Web服务器]
C-->CA[配置环境变量]
D-->DA[Tomcat]
DA-->BDA
B-->BDA[集成Tomcat]
S[Spring的JAR包]
COM[commons.logging的JAR包]

版本:

  • JDk:jdk-16_windows-x64_bin :arrow_right:jdk-15.0.2
  • Eclipse:Eclipse-2021-03#
  • Tomcat:apache-tomcat-9.0.44
  • Spring:spring-framework-5.1.4.RELEASE-dist.zip
  • commons.logging:commons-logging-1.2-bin.zip

第一个Spring入门程序

Spring解决的是业务逻辑层和其他各层的耦合问题,面向接口的编程思想

graph LR
TestDao[接口]-->TestDaoImpl[接口的实现类]-->applicationContext[配置文件]-->test[测试类]

核心容器

Spring的核心容器是其他模块建立的基础

Spring-core模块

Spring IoC控制反转 :Inversion of Control:用来消减计算机程序的耦合问题

BeanFactory

  
1
2
3
4
5
6
7
//创建BeanFactory实例时,需要提供XML文件的绝对路径
BeanFactory beanFac = new XmlBeanFactory(
new FileSystemResource("D:\\eclipse-workspace\\ch1\\src\\applicationContext.xml")
);
//通过容器获取test实例
TestDao tt = (TestDao)beanFac.getBean("test");
tt.sayHello();

ApplicationContext

创建ApplicationContext接口实例通常有三种方法:

  1. ClassPathXmlApplicationContext

    1
    2
    //从类路径classPath目录(src根目录)寻找指定的XML配置文件
    ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
  2. FileSystemXmlApplicationContext

    1
    2
    3
    //从指定文件的绝对路径中寻找XML配置文件
    //找到并装载完成ApplicationContext的实例化工作
    ApplicationContext appCon = new FileSystemXmlApplicationContext("D:\\eclipse-workspace\\ch1\\src\\applicationContext.xml");
  3. Web服务器实例化ApplicationContext容器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <!--web.xml>
    <!--一般使用基于org.springframework.web.context.ContextLoaderListener的实现方式.(需要将spring-web-5.0.2.RELEASE.jar复制到WEB-INF/lib目录中)-->
    <context-param>
    <!-- 加载src目录下的applicationContext.xml文件 -->
    <param-name>contextConfigLocation</param-name>
    <param-value>
    classpath:applicationContext.xml
    </param-value>
    </context-param>
    <!-- 指定以ContextLoaderListener方式启动Spring容器 -->
    <listener>
    <listener-class>
    org.springframework.web.context.ContextLoaderListener
    </listener-class>
    </listener>

DI依赖注入 :Dependency Injection:是IoC的另外一种说法,使用Spring框架创建对象时,动态地将其所依赖的对象(如属性值)注入Bean组件中,通常有两种实现方式。

构造方法注入:Spring框架可以采用Java的反射机制,通过构造方法完成依赖注入。在配置文件applicationContext.xml中,首先,将dao.TestDIDaoImpl类托管给Spring,让Spring创建其对象。其次,将service.TestDIServiceImpl类托管给Spring,让Spring创建其对象,同时给构造方法传递实参。

  
1
2
3
4
//初始化Spring容器ApplicationContext,加载配置文件
ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
//通过容器获取testDIService实例,测试构造方法注入
TestDIService ts = (TestDIService)appCon.getBean("testDIService");

setter方法注入

  1. 创建接口实现类
  2. 将接口类托管给Spring,让Spring创建其对象
  3. 调用接口类的setter方法完成依赖注入

  
1
2
3
4
5
6
7
8
9
10
11
12
      <!-- 使用setter方法注入 -->
<bean id="testDIService1" class="service.TestDIServiceImpl1">
<!-- 调用TestDIServiceImpl1类的setter方法,将myTestDIDao注入到 TestDIServiceImpl1类的属性testDIDao上-->
<property name="testDIDao" ref="myTestDIDao"/>
</bean>


> 反射机制:指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象,都能调用它的任意一个方法.这种动态获取信息,以及动态调用对象方法的功能叫java语言的反射机制.
>
> newInstance: 弱类型。低效率。只能调用无参构造。
>
> new: 强类型。相对高效。能调用任何public构造
  • Spring-beans模块

    • BeanFactory:工厂模式的一个经典实现
  • Spring-context模块:建立在Core和Beans模块基础上,提供一个框架式的对象访问方式,是访问定义和配置的任何对象的媒介。ApplicationContext接口是Context模块的焦点。

  • Spring-context-support模块:支持整合第三方库到Spring应用程序上下文,特别是用于高速缓存(EhCache,JCache)和任务调度(CommonJ,Quartz)的支持。

  • Spring-expression模块:提供了强大的表达式语言去支持运行时查询和操作对象图。

Spring的常用注解

1.声明Bean的注解

1
2
3
@Component 该注解是一个泛化的概念,仅仅表示一个组件对象(Bean),可以作用在任何层次上
@Repository 数据访问层(DAO) @Service 业务逻辑层 (Service) @Controller 控制器层
@ComponentScan:扫描含有@Component@Controller@Service@Repository的类,并将其注入到spring容器中

2.注入Bean的注解

1
2
3
@Autowired:类成员变量、方法及构造方法进行标注,完成自动装配的工作,消除setter和getter方法,默认按照Bean类型进行装配
@Resource:功能和@Autowired一样,默认按照名称来装配注入,只有当找不到与名称匹配的Bean才会按照类型来装配注入,@Resource注解有两个属性:name和type。
@Qualifier:当@Autowired需要按照名称来装配注入时,需要结合该注解一起

3.基于注解的依赖注入

  1. 省略set方法
  2. 省略XML文件中的
  3. 基于java配置的

Spring AOP和instrumentation

  • Spring-aop模块:提供了一个符合AOP要求的面向切面的编程实现,允许定义方法拦截器和切入点,将代码按照功能进行分离,以便干净地解耦。
  • Spring-aspects模块:提供了与AspectJ的集成功能,AspectJ是一个功能强大且成熟的AOP框架。
  • Spring-instrument模块:提供了类植入(instrumentation)支持和类加载器的实现,可以在特定的应用服务器中使用。
  • Spring-messaging模块:提供了对消息传递体系结构和协议的支持。

Spring Bean

Bean的配置:Spring框架支持XMLProperties两种格式的配置文件

1
2
3
4
5
6
7
<!-- 使用id属性定义myTestDIDao,其对应的实现类为dao.TestDIDaoImpl-->
<bean id="myTestDIDao" class="dao.TestDIDaoImpl" />
<!-- 使用构造方法注入 -->
<bean id="testDIService" class="service.TestDIServiceImpl">
<!--给构造方法传引用类型的参数值myTestDIDao-->
<constructor-arg index="0" ref="myTestDIDao"/>
</bean>

Bean的实例化

1.构造方法实例化

graph LR
BeanClass--id=constructorInstance-->applocatationContext.xml-->测试类
1
<bean id="constructorInstance" class="instance.BeanClass"/>
1
2
3
4
5
//TestInstanse.class
//初始化Spring容器ApplicationContext,加载配置文件
ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
//测试构造方法实例化Bean
BeanClass b1 = (BeanClass)appCon.getBean("constructorInstance");

2.静态工厂实例化

要求开发者在工厂类中创建一个静态方法来创建Bean的实例。配置Bean时,class属性指定静态工厂类,同时还需要使用factory-method属性指定工厂类中的静态方法。

graph LR
工厂类-->配置文件-->测试类
1
2
<!-- 静态工厂方法实例化Bean,createInstance为静态工厂类BeanStaticFactory中的静态方法-->
<bean id="staticFactoryInstance" class="instance.BeanStaticFactory" factory-method="createInstance"/>

3.实例工厂实例化

要求开发者在工厂类中创建一个实例方法来创建Bean的实例。配置Bean时,需要使用factory-bean属性指定配置的实例工厂,同时还需要factory-method属性指定实例工厂中的实例方法。

1
2
3
4
public class BeanInstanceFactory {
public BeanClass createBeanClassInstance() {
return new BeanClass("调用实例工厂方法实例化Bean");
}}
1
2
3
4
5
<!--applicationContext.xml-->
<bean id="myFactory" class="instance.BeanInstanceFactory"/>
<!-- 使用factory-bean属性指定配置工厂 ,
使用factory-method属性指定使用工厂中哪个方法实例化Bean-->
<bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance"/>

Bean的作用域

image-20210516174148628

  • singleton作用域:由于singleton是scope的默认方式,因此有两种方式将bean的scope设置为singleton。

    1
    2
    3
    <bean id="constructorInstance" class="instance.BeanClass"/>

    <bean id="constructorInstance" class="instance.BeanClass" scope="singleton"/>
  • prototype作用域

    1
    <bean id="constructorInstance" class="instance.BeanClass" scope="prototype"/>
  • Bean的生命周期

    1.根据Bean的配置情况,实例化一个Bean。

    2.根据Spring上下文对实例化的Bean进行依赖注入,即对Bean的属性进行初始化。

    3.如果Bean实现了BeanNameAware接口,将调用它实现的setBeanName(String beanId)方法,此处参数传递的是Spring配置文件中Bean的ID。

    4.如果Bean实现了BeanFactoryAware接口,将调用它实现的setBeanFactory()方法,此处参数传递的是当前Spring工厂实例的引用。

    5.如果Bean实现了ApplicationContextAware接口,将调用它实现的setApplicationContext(ApplicationContext)方法,此处参数传递的是Spring上下文实例的引用。

    6.如果Bean关联了BeanPostProcessor接口,将调用预初始化方法postProcessBeforeInitialization(Object obj, String s)对Bean进行操作。

    7.如果Bean实现了InitializingBean接口,将调用afterPropertiesSet()方法。

    8.如果Bean在Spring配置文件中配置了init-method属性,将自动调用其配置的初始化方法。

    9.如果Bean关联了BeanPostProcessor接口,将调用postProcessAfterInitialization(Object obj, String s)方法,由于是在Bean初始化结束时调用After方法,也可用于内存或缓存技术。
    以上工作(1至9)完成以后就可以使用该Bean,由于该Bean的作用域是singleton,所以调用的是同一个Bean实例。

    10.当Bean不再需要时,将经过销毁阶段,如果Bean实现了DisposableBean接口,将调用其实现的destroy方法将Spring中的Bean销毁。
    11.如果在配置文件中通过destroy-method属性指定了Bean的销毁方法,将调用其配置的销毁方法进行销毁。

Bean的装配方式:Bean的装配方式即Bean依赖注入的方式。Spring容器支持基于XML配置的装配基于注解的装配以及自动装配等多种装配方式。

数据访问/集成

数据访问/集成层由JDBC、ORM、OXM、JMS和事务模块组成。

  • Spring-jdbc模块:提供了一个JDBC 的抽象层,消除了繁琐的JDBC编码和数据库厂商特有的错误代码解析。
  • Spring-tx模块(事务模块):支持用于实现特殊接口和所有POJO(普通Java对象)类的编程和声明式事务管理。
  • Spring-orm模块:为流行的对象关系映射(Object-Relational Mapping )API提供集成层,包括JPA和Hibernate。使用Spring-orm模块,可以将这些O/R映射框架与Spring提供的所有其他功能结合使用,例如声明式事务管理功能。
  • Spring-oxm模块:提供了一个支持对象/XML映射的抽象层实现,如JAXB、Castor、JiBX和XStream。
  • Spring-jms模块(Java Messaging Service) :指Java消息传递服务,包含用于生产和使用消息的功能。自Spring 4.1后,提供了与Spring-messaging模块的集成。

web

Web层由Spring-web、Spring-webmvc、Spring-websocket和Portlet模块组成。

  • Spring-web模块:提供了基本的Web开发集成功能。例如:多文件上传功能、使用Servlet监听器初始化一个IoC容器以及Web应用上下文。
  • Spring-webmvc模块:也称为Web-Servlet模块,包含用于Web应用程序的Spring MVC和REST Web Services实现。 Spring MVC框架提供了领域模型代码和Web表单之间的清晰分离,并与 Spring Framework的所有其他功能集成。
  • Spring-websocket模块:Spring 4.0后新增的模块,它提供了WebSocket和SockJS的实现。
  • Portlet模块:类似于Servlet模块的功能,提供了在Portlet环境中使用MVC实现。

测试

  • Spring-test模块:支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。
1
2
3
4
5
6
7
8
9
<!--applicationContext.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">
<!-- 将指定类TestDaoImpl配置给Spring,让Spring创建其实例 -->
<bean id="test" class="dao.TestDaoImpl" />
</beans>
1
2
3
4
5
6
7
8
9
/**
* 测试类
**/
//初始化Spring容器ApplicationContext,加载配置文件
ApplicationContext appCon = new ClassPathXmlApplicationContext("applicationContext.xml");
//通过容器获取test实例
TestDao tt = (TestDao)appCon.getBean("test");
//test为配置文件中的id
tt.sayHello();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
*放射机制简单实例代码
**/
public class _14_ReflectTest07

{

public static void main(String[] args) throws Exception{

//1.获取类

Class c = Class.forName("_12_CustomerService");

//获取某个特定的方法

//通过:方法名+形参列表

Method m = c.getDeclaredMethod("login",String.class,String.class);

//通过反射机制执行login方法.

Object o = c.newInstance();

//调用o对象的m方法,传递"admin""123"参数,方法的执行结果是retValue

Object retValue = m.invoke(o, "admin","123");

System.out.println(retValue); //true

}

}

public class _12_CustomerService

{

//登录

public boolean login(String name,String pwd){

if("admin".equals(name) && "123".equals(pwd)){

return true;

}

return false;

}

//退出

public void logout(){

System.out.println("系统已安全退出!");

}

}

Spring MVC基础

P2

1
2
3
4
<!-- 前缀 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 后缀 -->
<property name="suffix" value=".jsp" />

Spring MVC

1.基于注解的控制器

2.MVC

视图解析器

1
2
3
4
5
6
7
8
9
10
11
/**
* 配置视图解析器
* @return
*/
@Bean
public InternalResourceViewResolver getViewResolver(){
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/jsp/");
viewResolver.setPrefix(".jsp");
return viewResolver;
}

静态资源

1
2
3
4
5
6
7
/**
* 配置静态资源
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/html/**").addResourceLocations("/html/");
}

拦截器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 配置拦截器Bean
*/
@Bean
public MyInteceptor myInteceptor(){
return new MyInteceptor();
}
/**
* 重写addInterceptors方法注册拦截器
*/
@Override
public void addInterceptors(InterceptorRegistry registry){
registry.addInterceptor(myInteceptor());
}

MultipartResolver配置

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* MultipartResolver配置
* @return
*/
@Bean
public MultipartResolver multipartResolver(){
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
//设置上传文件的最大值,单位为字节
multipartResolver.setMaxUploadSize(5400000);
//设置请求的编码格式,默认为iso-8859-1
multipartResolver.setDefaultEncoding("UTF-8");
return multipartResolver();
}

SpringMVC的常用注解

1
2
3
4

@ModelAttribute:
@RequestParam:@RequestParam(defaultValue="")
@RestController:

5.重定向和转发

graph LR
forward---u1[user]-->i1[index]-->t1[test]
redirect---u2[user]-->index
u2-->test
1
2
3
4
5
6
7
8
9
10
//转发:地址无变化,一个请求,同一服务器
@RequestMapping("/forward")
public String tiaozhuan(){
return "forward:/index/redirect"
}
//重定向:地址变化,不同服务器
@RequestMapping("/redirect")
public String red(){
return "redirect:/index/redirect"
}

6.文件上传

graph LR
jsp-->MultiFileDomain-->MultiFileConcroller
  1. 实体类
1
2
<form action enctype="multipart/form-data" method="post">
</form>
  1. 边界类
1
//MultifileDomain
  1. 控制类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//MultifileController
@Controller
public class MultiFileController{
private static final Logger
public String multFileUpload(){
String realPath;
File targerDir=new File(realPath);
//判断保存的文件夹是否存在
if(!targerDir.exists()){
targerDir.mkdir();//创建文件夹
}
//MultipartFile自动匹配页面的file对象
List<MultipartFile> files=multiFileDomain.getMyfile();
for(int i=0;i<files.size();i++){
MultipartFile file=files.get(i);//取索引赋值给 MultipartFile
String filename=file.getOriginalFilename();
File targetFile=new File(realpath,filename);
try{
file.tarnsferTo(targetFile);
}catch (Exception e){
e.printStackTrace();
}
}
Logger.info("上传成功");
return "showMulti";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//SpringMVCConfig
MultipatrResolver
MultipentFile
/**
* MultipartResolver配置
*/
@Bean
public MultipartResolver multipartResolver() {
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
//设置上传文件的最大值,单位为字节,5400000=5.4M
multipartResolver.setMaxUploadSize(5400000);
//设置请求的编码格式,默认为iso-8859-1
multipartResolver.setDefaultEncoding("UTF-8");
return multipartResolver;
}

jsp–div–>file[input type=’file’ name=’myfile’]–>MultipentFile
jsp–>text[description]–>description

Spring AOP

Spring AOP的基本概念

AOP采取横向抽取机制,即将分散在各个方法中的重复代码提取出来,然后在程序编译或运行阶段,再将这些抽取出来的代码应用到需要执行的地方。降低模块之间的耦合度,OOP实现的是父子关系的纵向重用。但是AOP不是OOP的替代品,而是OOP的补充,它们相辅相成。

image-20210516180453543

横向抽取机制

graph LR
A[类]--抽象-->B[对象]
B--实例-->A
c[关注点]--抽象-->d[切面]

image-20210516181041922

1.切面
切面(Aspect)是指封装横切到系统功能(如事务处理)的类。

2.连接点
一连接点(Joinpoint)是指程序运行中的一些时间点,如方法的调用或异常的抛出。

3.切入点
切入点(Pointcut)是指那些需要处理的连接点。一个匹配连接点的正则表达式。在Spring AOP 中,所有的方法执行都是连接点,而切入点是一个描述信息,它修饰的是连接点,通过切入点确定哪些连接点需要被处理。

4.通知(增强处理)
由切面添加到特定的连接点(满足切入点规则)的一段代码,即在定义好的切入点处所要执行的程序代码。可以将其理解为切面开启后,切面的方法。因此,通知是切面的具体实现。

5.引入
引入(Introduction)允许在现有的实现类中添加自定义的方法和属性。

6.目标对象
目标对象(Target Object)是指所有被通知的对象。如果AOP 框架使用运行时代理的方式(动态的AOP)来实现切面,那么通知对象总是一个代理对象。

7.代理
代理(Proxy)是通知应用到目标对象之后,被动态创建的对象。

8.组入(织入)
组入(Weaving)是将切面代码插入到目标对象上,从而生成代理对象的过程。根据不同的实现技术,AOP织入有三种方式:

  • 编译器织入,需要有特殊的Java编译器;-
  • 类装载期织入,需要有特殊的类装载器;
  • 动态代理织入,在运行期为目标类添加通知生成子类的方式。

Spring AOP框架默认采用动态代理织入,而AspectJ(基于Java语言的AOP框架)采用编译器织入和类装载期织入。

动态代理

JDK动态代理:JDK动态代理是java.lang.reflect.*包提供的方式,它必须借助一个接口才能产生代理对象。因此,对于使用业务接口的类,Spring默认使用JDK动态代理实现AOP。

CGLIB动态代理:一个高性能开源的代码生成包,采用非常底层的字节码技术,对指定的目标类生成一个子类,并对子类进行增强。在Spring Core包中已经集成了CGLIB所需要的JAR包,不需要另外导入JAR包。

基于代理类的AOP实现

Spring中默认使用JDK动态代理实现AOP编程。使用org.springframework.aop.framework.ProxyFactoryBean创建代理是Spring AOP实现的最基本方式。

AOP的术语

AOP实战-AspectJ

AOP(Aspect-Oriented Programming, ==面向切面编程==): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。

AOP 的主要编程对象是切面(aspect), 而切面是把横切关注点==模块化==!

在应用 AOP 编程时, 需要定义公共功能, 但可以明确的定义这个功能在哪里应用, 并且不必修改需要使用公共功能的类。 这样以来横切关注点就被模块化到特殊的对象(切面)里.

面向AOP编程程序员参与的3个部分:

  • 定义普通业务组件
  • 定义切入点
  • 定义通知,也叫增强处理

Spring通知的类型,前置通知,正常返回通知取决于在连接点执行前后时间,此为还有异常返回通知,连接点执行完成后执行最终通知。环绕通知,围绕在连接点前后,如一个方法调用的前后
切入点的定义

Spring Aop中切入点表达式大量使用execution表达式:
modifiers-pattern指定方法的修饰符(可省略)
ret-type-pattern
declaring-type-pattern

1
2
3
4
5
6
7
8
9
10
//任意公共方法的执行
execution(public * *(..))
//任何一个以‘set’开始的方法的执行
execution(*set*(..))
//AccountService接口的任意方法的执行
execution(*com.xyz.service.AccountService)
//定义在service包里的任意方法的执行
execution(*com.xyz.servuce.*.*(..))
//定义在service包或者子包里的任意方法的执行
execution(*com.xyz.servuce..*.*(..))

基于XML配置的AOP编程

  1. 添加支持AOP编程的JAR包

  2. 配置切面

  3. Spring Boot入门​和​核心

​ ==SpringBoot的基本配置、自动配置原理、条件注解==

MAVEN配置

1
2
3
4
5
6
MAVEN_HOME->目录
path=%MAVEN_HOME%\bin
cmd->mvn -v
maven.rar->D:
apache-maven-3.6.3>conf>settings><localRepository>d:\maven</localRepository>
Maven4MyEclipse>User Settings>apache-maven-3.6.3>conf>settings.xml

优点

  1. 编码简单
  2. 配置快捷
  3. 部署简便:内嵌Tomcat、Jetty等Web容器
  4. 监控容易

主要特性

  1. ==约定优于配置==
  2. 独立运行的Spring应用
  3. 内嵌Web容器
  4. 提供starter简化Maven配置
  5. 自动配置Spring
  6. 提供准生产的应用监控
  7. 无代码生成和XML配置

Maven

基于项目对象模型(Project Object Model,POM)

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- 核心启动器-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependency>
<groupId></groupId>
<artifactId></artifactId>
</dependency>
//IDEA
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
1
2
3
4
5
6
7
8
9
10
11
12
@SpringBootApplication
//组合注解,组合了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan
@SpringBootConfiguration
//because:该注解是一个组合注解,替代@Configuration
@SpringBootConfiguration包含{

}
@EnableAutoConfiguration
//读pom.xml文件,让SpringBoot根据当前应用项目所依赖的jar自动配置项目的相关配置。
@ComponentScan
//让SpringBoot自动扫描@SpringBootApplication所在类的同级别以及它的子包中的配置
//建议将@SpringBootApplication注解的入口类放置在项目包下,保证SpringBoot自动扫描项目所有包中的配置

全局配置文件

1
2
3
4
5
6
7
8
9
全局配置文件:放置在SB项目的resources目录下或者类路径的/config目录下
banner.txt
application.properties
{
server.port=8888
server.servlet.context-path=/ch3_1
spring.main.banner-mode=off
}
application.yml

读取应用配置

1
2
3
4
5
6
7
8
9
@Environment
//通用的读取应用程序运行时的环境变量的类,通过key-value方式读取application.properties、命令行输入参数、系统属性、操作系统环境变量等。
@Value("${test.msg}")
//test.msg为配置文件application.properties中的key
private String msg;
//通过@Value注解将配置文件中的key对应的Value赋值给变量msg
@ConfigurationProperties(prefix="obj")//obj为配置文件中key的前缀
@PropertySource({"my.properties","your.properties"})
//读取项目的其他配置文件
1
2
3
4
5
6
7
8
@ConfigurationProperties(prefix="")
//读取Application的信息
//开启属性配置类MyProperties提供参数
@EnableConfigurationProperties(MyProperties.class)
//类加载器中是否存在对应的类
@ConditionalOnClass(MyService.class)
//应用环境中属性是否存在指定的值
@ConditionalOnPropert(prefix="my",value="enabled",matchIfMissing=true)

日志配置

1
2
3
4
5
private Log log=LogFactory.getLog(LogTestController.class);
log.info("测试日志");
//日志级别有ERROR、WARN、INFO、DEBUG、TRACE
//设置日志的默认级别为info
logging.level.root=info

Spring Boot的web开发

1
2
3
4
5
<!--在pom.xml文件中添加依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

Thymeleaf模板引擎

Thymeleaf是一个Java类库,是一个XML/XHTML/HTML5的模板引擎

1
2
3
4
5
<!--pom.xml配置thymeleaf-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
1
2
3
4
5
public String test(HttpSession session,HttpServletRequest request){
session.setAttribute("skey","session范围的值");
request.setAttribute("rkey","request范围的值");
return "test";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--Thymeleaf基础语法-->
<!--1.引入Thymeleaf-->
<!--2.输出内容-->
<!--3.基本表达式-->
<!--4.引入URL-->
<!--5.访问WebContext对象中的属性-->
<!--6.运算符-->
<!--7.条件判断-->
<!--8.循环-->
<div th:each="user,usStat:${users}">
<table>
<td th:text="${usStat.index}"></td>
<td th:text="${user.uname}"></td>
<td th:text="${user.upass}"></td>
</tr>
</table>
<!--9.内置对象-->

Bootstrap框架

静态文件,样式表都用id取名

image-20210514082442063

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!--pom.xml-->
<!-- 配置将哪些资源文件(静态文件/模板文件/mapper文件)加载到tomcat输出目录里 -->
<resources>
<resource>
<directory>src/main/java</directory><!--java文件的路径-->
<includes>
<include>**/*.*</include>
</includes>
<!-- <filtering>false</filtering>-->
</resource>
<resource>
<directory>src/main/resources</directory><!--资源文件的路径-->
<includes>
<include>**/*.*</include>
</includes>
<!-- <filtering>false</filtering>-->
</resource>
</resources>

ajax

异步通信 局部刷新

1
2
3
4
5
6
7
8
9
<script type="text/javascript" th:src="@{js/jquery.js}"></script>
$.ajax({
key : "value",
url : "textJson",
dataType :"json",
type : "post",
contentType : "application/json",
data : JSON.stringify({}),
});
graph LR
a[ajax]-->url-->Controller
1
2
3
4
5
6
7
8
9
10
11
/**
* 接收页面请求的JSON数据
*/
@RequestMapping("/testJson")
@ResponseBody
/*@RestController注解相当于@ResponseBody + @Controller合在一起的作用。
1) 如果只是使用@RestController注解Controller,则Controller中的方法无法返回jsp页面或者html,
返回的内容就是Return的内容。
2) 如果需要返回到指定页面,则需要用 @Controller注解。如果需要返回JSON,XML或自定义mediaType内容到页面,
则需要在对应的方法上加上@ResponseBody注解。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
* ajax function()
*/
function testJson(){
//取页面信息,$()
var pname=$("#pname).val();
var password=$("#password).val();
var page=$("#page).val();
alert(panme);
$.ajax({
//Controller虚拟地址
url : "testJson",
dataType : "Json",
type : "post",
contentType : "application/json",
data : JSON.stringify({pname:pname,password:password,page:page}),
success:function(listdata){
var txt="";
if(listdata!=null){
for(var i=0;i<listdata.length;i++){
txt+=`<tr>
<td>${listdata[].pname}</td>
<td>${listdata[].password}</td>
<td>${listdata[].page}</td>
</tr>`
}
var tbody=$("<tbody></tbody>").html(txt);
$('#allp).html(tbody);
}
},
error:function(){
alert("访问失败");
},
});
}
1
2
<groupId>test</groupId>
<artifactId>Bootstrap</artifactId>

Spring Boot的数据访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<!--pom.xml-->
<!-- 添加MySQL依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.45</version>
<!-- MySQL8.x时,请使用8.x的连接器 -->
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!--添加Oracle的依赖-->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.1.0</version>
</dependency>
<!-- MyBatis-Spring,Spring Boot应用整合MyBatis框架的核心依赖配置 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
1
2
3
4
5
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.1.0</version>
</dependency>

application.properties

1
2
3
4
5
6
7
8
9
10
11
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#spring.datasource.url=jdbc:mysql://localhost:3306/ems
#spring.datasource.username=root
#spring.datasource.password=root
mybatis.mapper-locations=classpath:/static/Mapper/*.xml
server.port=8080
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521/ORCLLZD
spring.datasource.username=students
spring.datasource.password=123456
server.servlet.context-path=/testdb

工具

​```xml

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-freemarker</artifactId>
  </dependency>

```

未完待续。。。


本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!