Spring Boot学习笔记

Spring的体系结构

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接口实例通常有三种方法：

ClassPathXmlApplicationContext

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

FileSystemXmlApplicationContext

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

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.基于注解的依赖注入

省略set方法
省略XML文件中的
基于java配置的

Spring AOP和instrumentation

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

Spring Bean

Bean的配置：Spring框架支持XML和Properties两种格式的配置文件

<!-- 使用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"/>`

//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属性指定实例工厂中的实例方法。

public class BeanInstanceFactory {
	public BeanClass createBeanClassInstance() {
	    return new BeanClass("调用实例工厂方法实例化Bean");
    }}

<!--applicationContext.xml-->
    <bean id="myFactory" class="instance.BeanInstanceFactory"/>
<!-- 使用factory-bean属性指定配置工厂 ，
使用factory-method属性指定使用工厂中哪个方法实例化Bean-->
    <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance"/>

Bean的作用域

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组件进行单元测试和集成测试。

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

/**
 * 测试类
 **/
//初始化Spring容器ApplicationContext，加载配置文件
		ApplicationContext appCon = new         ClassPathXmlApplicationContext("applicationContext.xml");
		//通过容器获取test实例
		TestDao tt = (TestDao)appCon.getBean("test");
		//test为配置文件中的id
		tt.sayHello();

/**
*放射机制简单实例代码
**/
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基础

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

Spring MVC

1.基于注解的控制器

2.MVC

视图解析器

/**
 * 配置视图解析器
 * @return
 */
@Bean
public InternalResourceViewResolver getViewResolver(){
	InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
	viewResolver.setPrefix("/WEB-INF/jsp/");
	viewResolver.setPrefix(".jsp");
	return viewResolver;
}

静态资源

/**
 * 配置静态资源
 */
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
	registry.addResourceHandler("/html/**").addResourceLocations("/html/");
}

拦截器

/**
 * 配置拦截器Bean
 */
@Bean
public MyInteceptor myInteceptor(){
	return new MyInteceptor();
}
/**
 * 重写addInterceptors方法注册拦截器
 */
@Override
public void addInterceptors(InterceptorRegistry registry){
	registry.addInterceptor(myInteceptor());
}

MultipartResolver配置

/**
 * MultipartResolver配置
 * @return
 */
@Bean
public MultipartResolver multipartResolver(){
	CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
	//设置上传文件的最大值，单位为字节
	multipartResolver.setMaxUploadSize(5400000);
	//设置请求的编码格式，默认为iso-8859-1
	multipartResolver.setDefaultEncoding("UTF-8");
	return multipartResolver();
}

SpringMVC的常用注解


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

5.重定向和转发

graph LR
forward---u1[user]-->i1[index]-->t1[test]
redirect---u2[user]-->index
u2-->test

//转发：地址无变化，一个请求，同一服务器
@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 2	`<form action enctype="multipart/form-data" method="post"> </form>`

边界类

1	`//MultifileDomain`

控制类

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

//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的补充，它们相辅相成。

横向抽取机制

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

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

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

基于XML配置的AOP编程

添加支持AOP编程的JAR包
配置切面
Spring Boot入门和核心

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

MAVEN配置

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

优点

编码简单
配置快捷
部署简便：内嵌Tomcat、Jetty等Web容器
监控容易

主要特性

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

Maven

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

pom.xml

<!-- 核心启动器-->
	<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>

@SpringBootApplication
//组合注解，组合了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan
@SpringBootConfiguration
//because:该注解是一个组合注解，替代@Configuration
@SpringBootConfiguration包含{

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

全局配置文件

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

读取应用配置

@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"})
//读取项目的其他配置文件

@ConfigurationProperties(prefix="")
//读取Application的信息
//开启属性配置类MyProperties提供参数
@EnableConfigurationProperties(MyProperties.class)
//类加载器中是否存在对应的类
@ConditionalOnClass(MyService.class)
//应用环境中属性是否存在指定的值
@ConditionalOnPropert(prefix="my",value="enabled",matchIfMissing=true)

日志配置

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

Spring Boot的web开发

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

Thymeleaf模板引擎

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

<!--pom.xml配置thymeleaf-->
	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

public String test(HttpSession session,HttpServletRequest request){
    session.setAttribute("skey","session范围的值");
    request.setAttribute("rkey","request范围的值");
    return "test";
	}

<!--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取名

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

异步通信 局部刷新

<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

/**
 * 接收页面请求的JSON数据
 */
@RequestMapping("/testJson")
@ResponseBody
/*@RestController注解相当于@ResponseBody ＋ @Controller合在一起的作用。
1) 如果只是使用@RestController注解Controller，则Controller中的方法无法返回jsp页面或者html，
返回的内容就是Return的内容。
2) 如果需要返回到指定页面，则需要用 @Controller注解。如果需要返回JSON，XML或自定义mediaType内容到页面，
则需要在对应的方法上加上@ResponseBody注解。
   */

/**
	 * 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的数据访问

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

<dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.1.0</version>
        </dependency>

application.properties

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

```

未完待续。。。

Java SSM

Java Spring Boot 笔记

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

SSM框架-Spring 获取对象原理 Previous

博客美化之路 Next

Spring Boot学习笔记

Spring Boot学习笔记

Spring基础

核心容器

Spring的常用注解

Spring AOP和instrumentation

Spring Bean

数据访问/集成

web

测试

Spring MVC基础

Spring MVC

1.基于注解的控制器

2.MVC

视图解析器

静态资源

拦截器

MultipartResolver配置

SpringMVC的常用注解

5.重定向和转发

6.文件上传

Spring AOP

Spring AOP的基本概念

动态代理

基于代理类的AOP实现

基于XML配置的AOP编程

Spring Boot入门​和​核心

MAVEN配置

Maven

pom.xml

日志配置

Spring Boot的web开发

Thymeleaf模板引擎

Bootstrap框架

ajax

Spring Boot的数据访问

application.properties

工具

未完待续。。。

Spring Boot入门和核心