关键词:
一、JavaConfig
在Spring3.0之前,我们的bean一直通过XML文件来配置的,后来在Spring3.0之后为我们提供了Java的config版本。而且在Spring4.0之后推荐我们使用
JavaConfig: 是 Spring 提供的使用 java 类配置容器。 配置 Spring IOC 容器的纯 Java 方法
JavaConfig优点:
1、面向对象的配置:
由于配置被定义为JavaConfig中的类,因此可以充分使用Java中的面向对象功能。一个配置类可以继承另一个配置类,重写@Bean方法
2、减少或者消除XML配置:
JavaConfig提供了一种纯Java的方法来配置与XML配置概念相似的Spring容器。
从技术角度来说,只使用javaconfig配置类来配置容器是可行的,但是实际开发中,很多场景都是JavaConfig和XML配置共用是最方便,最理想
3、类型安全和重构好:
JavaConfig提供了一种类型安全的方法了来配置spring容器,由于Java5.0对泛型的支持,现在可以按类型而不是名称检索bean,不需要任何的强制转换或者基于字符串的查找
JavaConfig使用的主要注解
@Configuration:表示当前类作为配置文件使用(配置容器,放在类的上面;等同 xml 配置文件,可以在其中声明 bean )
@ComponentScan:定义的包路径,自动扫描包路径下面的所有被@Controller、@Service、@Repository、@Component 注解标识的类,然后装配到Spring容器中 * 等同 xml 中 <context:component-scan base-package="com.mycompany.vo" />
@ImportResource:导入其他的xml配置文件;等同 xml中 <import resources="其他配置文件"/>
@PropertySource:读取properties属性配置文件 ;等同 xml文件中 <context:property-placeholder location="classpath:config.properties" />
@Bean:将对象注入到Spring容器中(类似<bean>标签,放在方法上面);不指定对象的名称,默认是方法名是 id
创建一个maven Java工程,目录如下
resources下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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<bean id="myStudent" class="com.mycompany.vo.Student">
<property name="stuId" value="1"/>
<property name="stuName" value="zhangsan"/>
</bean>
<!-- <context:property-placeholder location="classpath:config.properties" />-->
<!-- <context:component-scan base-package="com.mycompany.vo" />-->
<!-- <import resource="classpath:beans.xml" />-->
</beans>
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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--声明bean对象-->
<bean id="myUser" class="com.mycompany.vo.User">
<property name="userId" value="1" />
<property name="useName" value="admin" />
</bean>
</beans>
config.properties
shop.shopId=1
shop.shopName=东东
vo对象
public class Student
private Long stuId;
private String stuName;
public Long getStuId()
return stuId;
public void setStuId(Long stuId)
this.stuId = stuId;
public String getStuName()
return stuName;
public void setStuName(String stuName)
this.stuName = stuName;
@Override
public String toString()
return "Student" +
"stuId=" + stuId +
", stuName='" + stuName + '\'' +
'';
public class User
private Long userId;
private String useName;
public Long getUserId()
return userId;
public void setUserId(Long userId)
this.userId = userId;
public String getUseName()
return useName;
public void setUseName(String useName)
this.useName = useName;
@Override
public String toString()
return "User" +
"userId=" + userId +
", useName='" + useName + '\'' +
'';
@Component("shop")
public class Shop
@Value("$shop.shopId")
private Long shopId;
@Value("$shop.shopName")
private String shopName;
public Long getShopId()
return shopId;
public void setShopId(Long shopId)
this.shopId = shopId;
public String getShopName()
return shopName;
public void setShopName(String shopName)
this.shopName = shopName;
@Override
public String toString()
return "Shop" +
"shopId=" + shopId +
", shopName='" + shopName + '\'' +
'';
SpringConfig.java
import com.mycompany.vo.Student;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
/**
* @Configuration: 表示当前类作为配置文件使用(配置容器,放在类的上面)
* 作用:相当于 beans.xml
*/
@Configurable
/**
* @ImportResource: 导入其他的xml配置文件
* 等同 xml中 <import resources="其他配置文件"/>
*/
@ImportResource(value = "classpath:applicationContext.xml","classpath:beans.xml")
/**
* @PropertyResource: 读取properties属性配置文件
* 等同 xml文件中 <context:property-placeholder location="classpath:config.properties" />
*/
@PropertySource(value = "classpath:config.properties")
/**
* @ComponentScan: 定义的包路径,自动扫描包路径下面的所有被@Controller、@Service、@Repository、@Component 注解标识的类,然后装配到Spring容器中
* 等同 xml 中 <context:component-scan base-package="com.mycompany.vo" />
*/
@ComponentScan(basePackages = "com.mycompany.vo")
public class SpringConfig
/**
* @Bean: 将对象注入到Spring容器中(类似<bean>标签,放在方法上面)
* @Bean ,不指定对象的名称,默认是方法名是 id,如:createStudent
*/
@Bean
public Student createStudent()
Student s1 = new Student();
s1.setStuId(20L);
s1.setStuName("张三");
return s1;
/***
* 指定对象在容器中的名称(指定<bean>的id属性)
* @Bean 的name属性,指定对象的名称(id)
*/
@Bean(name = "lisiStudent")
public Student createStudent1()
Student s2 = new Student();
s2.setStuId(20L);
s2.setStuName("李四");
return s2;
测试类
/**
* 使用xml作为容器配置文件
*/
@Test
public void test0()
String config = "beans.xml";
ApplicationContext context = new ClassPathXmlApplicationContext(config);
User myUser = (User) context.getBean("myUser");
System.out.println("容器中对象:" + myUser);
@Test
public void test1()
String config = "applicationContext.xml";
ApplicationContext context = new ClassPathXmlApplicationContext(config);
Student student = (Student) context.getBean("myStudent");
System.out.println("容器中对象:" + student);
/**
* 使用JavaConfig
*/
@Test
public void test2()
//AnnotationConfigApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
Student student = (Student) context.getBean("createStudent");
System.out.println("使用JavaConfig创建的bean对象:" + student);
@Test
public void test3()
//AnnotationConfigApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
Student student = (Student) context.getBean("lisiStudent");
System.out.println("使用JavaConfig创建的bean对象:" + student);
@Test
public void test4()
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
User user = (User) ctx.getBean("myUser");
System.out.println("user=="+user);
@Test
public void test5()
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
Shop shop = (Shop) ctx.getBean("shop");
System.out.println("shop=="+shop);
二、SpringBoot
1、SpringBoot简介
众所周知 Spring 应用需要进行大量的配置,各种 XML 配置和注解配置让人眼花缭乱,且极容易出错,因此 Spring 一度被称为“配置地狱”。
为了简化 SpringMVC + Spring + MyBatis 框架 应用的搭建和开发过程,Pivotal 团队在 Spring 基础上提供了一套全新的开源的框架,它就是 Spring Boot(核心依然是IOC容器 )
Spring Boot 是 Pivotal 团队在 Spring 的基础上提供的一套全新的开源框架,其目的是为了简化 Spring 应用的搭建和开发过程。Spring Boot 去除了大量的 XML 配置文件,简化了复杂的依赖管理。
Spring Boot 具有 Spring 一切优秀特性,Spring 能做的事,Spring Boot 都可以做,而且使用更加简单,功能更加丰富,性能更加稳定而健壮。随着近些年来微服务技术的流行,Spring Boot 也成了时下炙手可热的技术。
Spring Boot 集成了大量常用的第三方库配置,Spring Boot 应用中这些第三方库几乎可以是零配置的开箱即用(out-of-the-box),大部分的 Spring Boot 应用都只需要非常少量的配置代码(基于 Java 的配置),开发者能够更加专注于业务逻辑。
官网地址:Spring Boot
SpringBoot特点
1、Create stand-alone Spring applications
创建spring应用
2、Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
内嵌tomcat, jetty , Undertow
3、Provide opinionated 'starter' dependencies to simplify your build configuration
提供了starter起步依赖,简化应用的配置
比如使用MyBatis框架 , 需要在Spring项目中,配置MyBatis的对象 SqlSessionFactory , Dao的代理对象
在SpringBoot项目中,在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖
4、Automatically configure Spring and 3rd party libraries whenever possible
尽可能自动配置Spring和第三方库,把spring中的,第三方库中的对象都创建好,放到容器中, 可以直接使用
5、Provide production-ready features such as metrics, health checks, and externalized configuration
提供可用于生产的特性,如度量、健康检查和外部化配置
6、Absolutely no code generation and no requirement for XML configuration
完全不需要代码生成,也不需要XML配置
2、SpringBoot项目创建
1、第一种:https://start.spring.io
1、IDEA中新建一个项目,选择 Spring Initializr
2019版本的IDEA,直接选择Default 的URL:https://start.spring.io
2021版本的IDEA如下
然后依次输入项目\模块名, 项目保存位置,创建方式 Maven,语言Java,Group组织ID,Artifact,工程SDK版本,打包方式等
2、选择依赖版本
可选择Spring Boot的版本,以及需要用到的依赖列表
3、项目\模块目录结构
pom.xml中默认依赖如下
<dependencies>
<!-- web项目起步依赖 -->
<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>
2、第二种方式:https://start.springboot.io
2019版本的IDEA,选择Custom的URL:https://start.springboot.io
https://start.springboot.io 是国内提供的 springboot初始化器地址
2021版本的IDEA如下
3、第三种:Maven
1、创建普通的 Maven 项目
2、手动添加 static,templates 等目录结构
3、pom.xml 文件中添加依赖
<dependencies>
<!-- web项目起步依赖 -->
<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>
4、创建启动类:加入@SpringBootApplication 注解
/**
* @SpringBootApplication
* 符合注解:由
* @SpringBootConfiguration
* @EnableAutoConfiguration
* @ComponentScan
* 三个注解组成
*
* 1、@SpringBootConfiguration
* @Configuration
* public @interface SpringBootConfiguration
* @AliasFor(
* annotation = Configuration.class
* )
* boolean proxyBeanMethods() default true;
*
* 使用了@SpringBootConfiguration注解标注的类,可以作为配置文件使用的,可使用Bean声明对象,注入到容器
*
* 2、@EnableAutoConfiguration
* 启用自动配置, 把java对象配置好,注入到spring容器中。例如可以把mybatis的对象创建好,放入到容器中
*
* 3、@ComponentScan 扫描器,找到注解,根据注解的功能创建对象,给属性赋值等等
* 默认扫描的包: @ComponentScan所在的类所在的包和子包
*/
@SpringBootApplication
public class Springboot2HelloApplication
public static void main(String[] args)
SpringApplication.run(Springboot2HelloApplication.class, args);
@SpringBootApplication符合注解:由 @SpringBootConfiguration 、@EnableAutoConfiguration 、@ComponentScan 三个注解组成
1、@SpringBootConfiguration
@SpringBootConfiguration注解标注的类,可以作为配置文件使用的,可使用Bean声明对象,注入到容器
2、@EnableAutoConfiguration 启用自动配置, 把java对象配置好,注入到spring容器中
例如可以把mybatis的对象创建好,放入到容器中
3、@ComponentScan 扫描器,找到注解,根据注解的功能创建对象,给属性赋值等等默认扫描的包
@ComponentScan所在的类所在的包和子包
启动应用,我们看控制台会内嵌一个Tomcat(默认端口8080,博主因为端口被占用,改成了8081)
以及其依赖 jar 包
3、SpringBoot配置文件,以及多环境设置
Spring Boot 的核心配置文件用于配置 Spring Boot 程序,名字必须以 application 开始
1、配置文件名称: application
扩展名有: properties( k=v) ;yml ( k: v)
application.properties(默认采用该文件)
application.yml
yml 是一种 yaml 格式的配置文件,主要采用一定的空格、换行等格式排版进行配置。
yaml 是一种直观的能够被计算机识别的的数据序列化格式,容易被人类阅读,yaml 类似于 xml,但是语法比 xml 简洁很多,值与前面的冒号配置项必须要有一个空格, yml缀也可以使用 yaml 后缀
要么使用application.properties,要么使用 application.yml,不要同时使用(springboot默认采用是键值对的 application.properties 属性配置文件)
注意 : 当两种格式配置文件同时存在 ,在 SpringBoot2.4 开始, 使用的是 yml 配置文件
(1)application.properties 设置 端口和上下文
#设置端口号
server.port=8081
#设置访问应用上下文路径, contextpath
server.servlet.context-path=/myboot
(2)application.yml 设置 端口和上下文
server:
port: 8083
servlet:
context-path: /myboot2
在application.yml 文件书写注意:
1、不同 “等级” 用冒号隔开
2、次等级的前面是空格(最好2个空格),不能使用制表符(tab)
3、冒号之后如果有值,那么冒号和值之间至少有一个空格,不能紧贴着
2、多环境设置
创建多个配置文件, 名称规则: application-环境名称.properties(yml)
如:application-dev.properties( application-dev.yml );
application-test.properties( application-test.yml );
在application.properties(yml) 中设置使用的环境名 spring.profiles.active 即可
application.properties中
#设置环境
spring.profiles.active=dev
application.yml中
#设置多环境
spring:
profiles:
active: dev
3、application.properties(yml) 自定义配置
SpringBoot 的核心配置文件中,除了使用内置的配置项之外,我们还可以在自定义配 置,然后采用@Value 注解,@ConfigurationProperties 注解去读取配置的属性值
1、@Value 注解
@Value("$key") , key 来自 application.properties(yml)
#设置端口号
server:
port: 8081
servlet:
context-path: /myBook
#设置book信息
book:
bookname: 《三十而立》
bookprice: 68.50
#访问网站
website: www.baidu.com
2、@ConfigurationProperties 注解
@ConfigurationProperties: 把配置文件的数据映射为java对象
属性:prefix 配置文件中的某些key的开头的内容
@Component 标注一个类为Spring容器的Bean(把普通pojo实例化到spring容器中,等同 xml 配置文件中的<bean id="" class=""/>)
/**
* @Component 标注一个类为Spring容器的Bean(把普通pojo实例化到spring容器中,等同 xml 配置文件中的<bean id="" class=""/>)
*/
@Component
/**
* @ConfigurationProperties: 把配置文件的数据映射为java对象
* 属性:prefix 配置文件中的某些key的开头的内容
*/
@ConfigurationProperties(prefix = "book")
public class Book
private String bookName;
private Double bookPrice;
public String getBookName()
return bookName;
public void setBookName(String bookName)
this.bookName = bookName;
public Double getBookPrice()
return bookPrice;
public void setBookPrice(Double bookPrice)
this.bookPrice = bookPrice;
@Override
public String toString()
return "Book" +
"bookName='" + bookName + '\'' +
", bookPrice=" + bookPrice +
'';
我们在加入@ConfigurationProperties 注解时,会报如下警告
Spring Boot Configuration Annotation Processor not configured
我们在pom.xml 依赖中加入如下依赖
<!--处理ConfigurationProperties有关的元数据
加入@ConfigurationProperties注解时报错:Spring Boot Configuration Annotation Processor not configured
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
测试请求
@Controller
public class MyController
@Value("$server.port")
private Integer port;
@Value("$server.servlet.context-path")
private String contextPath;
@Value("$book.bookname")
private String bookName;
@Value("$book.bookprice")
private Double bookPrice;
@Value("$website")
private String webSite;
@Autowired
private Book book;
@RequestMapping("/data")
@ResponseBody
public String queryData()
return bookName + " " + bookPrice + ",webSite=" + webSite + ", 项目的访问地址=" + contextPath + ",使用的端口=" + port;
@RequestMapping("/book")
@ResponseBody
public String queryInfo()
return "book对象==" + book.toString();
输出如下:
springboot-springboot集成rabbitmq
一、SpringBoot集成RabbitMQ创建两个模块,一个命名springboot-send,一个命名springboot-receive在两个工程的pom.xml配置文件中引入AMQP依赖<dependencies><dependency><groupId>org.springframework.boot</groupId 查看详情
springboot-springboot配置说明(代码片段)
端口号server.port=8000WebURLserver.context-path=/config服务器ip地址server.address=设置httpheader大小注意此处tomcat6-7中默认是8192即8k并且每一个连接都会开辟一个8k的cache修改配置一定注意server.max-http-header-size=设置返回http头server 查看详情
java闭关修炼springboot-springboot整合其他框架(代码片段)
【Java闭关修炼】SpringBoot-SpringBoot整合其他框架SpringBoot整合Junit实现步骤Springboot整合redisSpringboot整合mybatis勾选依赖配置datasource数据源信息定义Mapper接口测试UserXmlMapper配置SpringBoot整合Junit实现步骤用于单元测试首先编写一个业务... 查看详情
redis简介安装和基础入门
--------------------------------------------------------主要内容包括:1、Redis简介2、Reds安装、启动、停止--------------------------------------------------------1、Redis简介 & 查看详情
webservice入门简介(一个简单的webservice示例)
WebService入门简介(一个简单的WebService示例)WebService入门简介一、WebService简介1.1、WebService基本概念WebService也叫XMLWebServiceWebService是一种可以接收从Internet或者Intranet上的其它系统中传递过来的请求,轻量级的独立的通讯技术。是:通... 查看详情
hibernate入门简介----张冬
简单的Hibernate入门简介转自:http://blog.csdn.net/doodoofish/article/details/43207其实Hibernate本身是个独立的框架,它不需要任何webserver或applicationserver的支持。然而,大多数的Hibernate入门介绍都加入了很多非Hibernate的东西,... 查看详情
springmvc入门系列-springmvc简介与入门(代码片段)
SpringMVC简介与入门什么是SpringMvc?SpringMVC:是基于spring的一个框架,实际上就是spring的一个模块。专门是做web开发的。理解是servlet的一个升级web开发底层是servlet,框架是在servlet基础上面加入一些功能,让你做veb开发方便。springMV... 查看详情
kafka快速入门——confluentkafka简介(代码片段)
Kafka快速入门(八)——ConfluentKafka简介一、ConfluentKafka简介1、ConfluentKafka简介2014年,Kafka的创始人JayKreps、NahaNarkhede和饶军离开LinkedIn创立Confluent公司,专注于提供基于Kafka的企业级流处理解决方案,并发布了ConfluentKafka。ConfluentK... 查看详情
docker的入门简介
...是很完美,需要大家指正修改和意见(谢谢合作)docker的入门:docker的好处:1.更快交付你的应用(Fasterdeliveryofyourapplications)2.让部署和测试更加简单(Deployingandscalingmoreeasily)3.实现更高密度和更多的负载 (Achievinghigherdensi... 查看详情
nginx入门简介
nginx入门简介nginx介绍Nginx反向代理与负载均衡什么是反向代理什么是负载均衡nginx的优势nginx介绍nginx是一个高性能的HTTP和反向代理服务器,其特点是占用内存少,并发能力强。Nginx反向代理与负载均衡什么是反向代理反向代理(... 查看详情
nginx入门简介
nginx入门简介nginx介绍Nginx反向代理与负载均衡什么是反向代理什么是负载均衡nginx的优势nginx介绍nginx是一个高性能的HTTP和反向代理服务器,其特点是占用内存少,并发能力强。Nginx反向代理与负载均衡什么是反向代理反向代理(... 查看详情
java入门及简介
1简单的学习了java的历史及其发展情况2安装了java3简单认识了一下java并练习了一下 3.1新建一个.txt文本文档; 键入: classHello { publicstaticvoidmain(String[]args) { System.out.println("☆... 查看详情
node.js入门简介
Node.js简介1.1简介V8引擎本身就是用于Chrome浏览器的JS解释部分,但是RyanDahl鬼才般的把这个V8搬到了服务器上,用于做服务器的软件。Node.js是一个专注于实现高性能Web服务器优化的专家,几经探索,几经挫折后,遇到V8而诞生的项... 查看详情
spring入门简介
Spring概况 Spring的简介 Spring是一个轻量级的控制反转和面向切面的容器框架,它主要是为了解决企业应用开发的复杂性而诞生的: 目的:解决企业应用开发的复杂性 功... 查看详情
spring入门简介
Spring概况Spring的简介 Spring是一个轻量级的控制反转和面向切面的容器框架,它主要是为了解决企业应用开发的复杂性而诞生的: 目的:解决企业应用开发的复杂性 功能:使用... 查看详情
docker快速入门——docker简介(代码片段)
Docker快速入门——Docker简介一、Docker简介1、Docker简介Docker是DockerInc公司开源的一项基于UbuntuLXC技术构建的应用容器引擎,源代码托管在GitHub上,完全基于go语言开发并遵守Apache2.0协议开源。Docker可以让开发者打包应用以及依赖包... 查看详情
kafka入门:简介使用场景主要配置
一、入门 1、简介 Kafkaisadistributed,partitioned,replicatedcommitlogservice。它提供了类似于JMS的特性,但是在设计实现上完全不同,此外它并不是JMS规范的实现。kafka对消息保存时根据Topic进行归类,发送消息者成为Producer,... 查看详情
python3快速入门——python简介(代码片段)
Python3快速入门(一)——Python简介一、Python简介1、Python简介Python是一种解释型、面向对象、动态数据类型的高级程序设计语言,由荷兰GuidovanRossum于1989年底发明,第一个公开发行版于1991年发布,Python源代码遵循GPL(GNUGeneralPublicL... 查看详情