spring 的配置介绍
spring快速入门
Spring程序开发步骤
①导入 Spring 开发的基本包坐标
②编写 Dao 接口和实现类
③创建 Spring 核心配置文件
④在 Spring 配置文件中配置 UserDaoImpl
⑤使用 Spring 的 API 获得 Bean 实例
导入Spring开发的基本包坐标
在pom.xml中导入spring的jar包
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.3.RELEASE</version> <scope>compile</scope> </dependency> </dependencies>
然后我们编写一个Dao接口 和接口的实现类
Dao接口UserDao
public interface UserDao { public void save(); }
接口的实现类UserDaoImpl
public class UserDaoImpl implements UserDao { public void save(){ System.out.println("save Running....."); } }
创建Spring核心配置文件
在类路径下(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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl"></bean> </beans>
使用Spring的API获得Bean实例
public class UserDaoDemo { public static void main(String[] args) { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao) app.getBean("userDao"); userDao.save(); } }
项目结构:
Spring配置文件
Bean标签基本配置
用于配置对象交由Spring 来创建。
默认情况下它调用的是类中的无参构造函数,如果没有无参构造函数则不能创建成功。
基本属性: id:Bean实例在Spring容器中的唯一标识 class:Bean的全限定名称
<bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl"></bean> id为你启的一个别名,是唯一性,class指定的是你的项目中一个类
Bean标签范围配置
scope:指对象的作用范围,取值如下:
取值范围 | 说明 |
singleton | 默认值,单例的 |
prototype |
多例的 |
request | WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中 |
session |
WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中 |
global |
WEB 项目中,应用在 Portlet 环境,如果没有 Portlet 环境那么globalSession 相当于 |
当scope的取值为singleton时
.
Bean的实例化个数:1个 Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例 Bean的生命周期: 对象创建:当应用加载,创建容器时,对象就被创建了 对象运行:只要容器在,对象一直活着 对象销毁:当应用卸载,销毁容器时,对象就被销毁了
eg:
在配置的bean标签中加上scope="singleton"
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" scope="singleton"></bean>
然后看到获取的bean对象是相同的一个
@Test public void TestMonday(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao1 = (UserDao) app.getBean("userDao"); UserDao userDao2 = (UserDao)app.getBean("userDao"); System.out.println(userDao1); // com.springTestTwo.Impl.UserDaoImpl@2d8f65a4 System.out.println(userDao2); // com.springTestTwo.Impl.UserDaoImpl@2d8f65a4 }
singleton只创建一个bean对象因为配置文件只在上面加载一次
输出
UserDaoImpl对象被创建 --- 虽然创建了两次对象但是都是同一个对象并且只创建一个对象
com.springTestTwo.Impl.UserDaoImpl@2d8f65a4
com.springTestTwo.Impl.UserDaoImpl@2d8f65a4
当scope的取值为prototype时
Bean的实例化个数:多个
Bean的实例化时机:当调用getBean()方法时实例化Bean
对象创建:当使用对象时,创建新的对象实例
对象运行:只要对象在使用中,就一直活着
对象销毁:当对象长时间不用时,被 Java 的垃圾回收器回收了
applicationContext.xml配置
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" scope="prototype"></bean>
可以看到是获取的不同的bean对象
@Test public void TestMonday(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao1 = (UserDao) app.getBean("userDao"); UserDao userDao2 = (UserDao)app.getBean("userDao"); System.out.println(userDao1); // com.springTestTwo.Impl.UserDaoImpl@1786dec2 System.out.println(userDao2); // com.springTestTwo.Impl.UserDaoImpl@74650e52 }
输出:
UserDaoImpl对象被创建
UserDaoImpl对象被创建
com.springTestTwo.Impl.UserDaoImpl@1786dec2
com.springTestTwo.Impl.UserDaoImpl@74650e52
我们可以看到生成的对象也是根据getBean的次数,getBean了两次所以就是生成了两个对象
Bean生命周期配置
init-method:指定类中的初始化方法名称
destroy-method:指定类中销毁方法名称
现在接口实现类中创建好要执行的初始化方法和销毁方法
public void init(){ System.out.println("初始化方法"); } public void destory(){ System.out.println("销毁方法"); }
然后配置文件的bean中配置方法
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" init-method="init" destroy-method="destory"></bean>
Bean实例化三种方式
1:使用无参构造方法实例化
它会根据默认无参构造方法来创建类对象,如果bean中没有默认无参构造函数,将会创建失败
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl"></bean>
2:工厂静态方法实例化
工厂的静态方法返回Bean实例
首先创建工厂类:
工厂类中指定类的
public class StaticFactory { public static UserDao getUserDao(){ return new UserDaoImpl(); } }
然后配置文件的bean中指定工厂类
factory-method方法指定你的工厂类的方法
<bean id="staticFactory" class="com.springTestTwo.factory.StaticFactory" factory-method="getUserDao"></bean>
test:
@Test public void TestWednesday(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao staticFactory = (UserDao) app.getBean("staticFactory"); System.out.println(staticFactory); //com.springTestTwo.Impl.UserDaoImpl@7a765367 }
3: 工厂实例方法实例化
工厂的非静态方法返回Bean实例
public class DynamicFactoryBean { public UserDao createUserDao(){ return new UserDaoImpl(); } }
<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/> <bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
Bean的依赖注入入门
①创建 UserService,UserService 内部在调用 UserDao的save() 方法
UserService
public interface UserService { public void save(); }
创建UserService的实现类:UserServiceImpl
public class UserServiceImpl implements UserService { public void save(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao)app.getBean("userDao"); userDao.save(); } }
然后配置文件内的bean的指向依旧不变
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" ></bean>
test:
public static void main(String[] args) { UserService userService = new UserServiceImpl(); userService.save(); }
②将 UserServiceImpl 的创建权交给 Spring
我们还可以:调用指向UserSericeImpl的配置文件
<bean id="userService" class="com.springTestTwo.service.Impl.UserServiceImpl"></bean>
③从 Spring 容器中获得 UserService 进行操作
public static void main(String[] args) { UserService userService = new UserServiceImpl(); userService.save(); } 或者使用
public static void main(String[] args) {
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) app.getBean("userService"); // 直接获取UserServiceImpl这个实现类
userService.save();
}
上面这两种获取其实都是直接去获取了 UserDao又去创建了一遍那样是不太合适的,我们可以只使用UserService然后不管
其实就是spring容器创建了 UserDao然后,然后UserServiceImpl再调用容器创建好的对象
因为UserService和UserDao都在Spring容器内部,而最终程序直接使用的是UserService,所以可以在Spring容器中.将UserDao设置到UserService内部
Bean的依赖注入概念
依赖注入(Dependency Injection):它是 Spring 框架核心 IOC 的具体实现。
在编写程序时,通过控制反转,把对象的创建交给了 Spring,但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系,但不会消除。例如:业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系,在使用 Spring 之后,就让 Spring 来维护了。
简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取
Bean的依赖注入方式
①构造方法
创建有参构造
private UserDao userDao; public UserServiceImpl(UserDao userDao) { this.userDao = userDao; }
配置Spring容器调用有参构造时进行注入
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" ></bean> <bean id="userService" class="com.springTestTwo.service.Impl.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao"></constructor-arg> <!-- name 指的就是你的实现类中构造函数中的参数,我的userServiceImpl.java中的构造函数中的参数是userDao ref就是你引用的bean--> </bean>
test:运行类
public static void main(String[] args) { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = (UserService) app.getBean("userService"); // 直接获取UserServiceImpl这个实现类 userService.save(); }
②set方法
在UserServiceImpl中添加setUserDao方法
public class UserServiceImpl implements UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void save(){
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");
userDao.save();
} }
application.xml配置文件
配置Spring容器调用set方法进行注入
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" ></bean> <!-- <bean id="staticFactory" class="com.springTestTwo.factory.StaticFactory" factory-method="getUserDao"></bean>--> <bean id="userService" class="com.springTestTwo.service.Impl.UserServiceImpl"> <property name="userDao" ref="userDao"/> <!-- name 中的名字就是 UserServiceImpl中的set方法的名字小写即可 方法名子setUserDao--> </bean>
property 中的name就是实现类中的设置的set方法后面的方法名,ref就是上面配置的UserDao的bean实现id
Test:
public class UserServiceDemo { public static void main(String[] args) { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = (UserService) app.getBean("userService"); // 直接获取UserServiceImpl这个实现类 userService.save(); } }
set方法:P命名空间注入
P命名空间注入本质也是set方法注入,但比起上述的set方法注入更加方便,主要体现在配置文件中,如下:
首先,需要引入P命名空间:
在applicationXontext.xml中顶部配置命名空间
xmlns:p="http://www.springframework.org/schema/p"
其次,需要修改注入方式
然后修改指向的bean配置
<bean id="userService" class="com.springTestTwo.service.Impl.UserServiceImpl" p:userDao-ref="userDao"></bean>
Bean的依赖注入的数据类型
上面的操作,都是注入的引用Bean,处了对象的引用可以注入,普通数据类型,集合等都可以在容器中进行注
入。
注入数据的三种数据类型
普通数据类型
引用数据类型
集合数据类型
普通数据类型:
在userDaoImpl中设置参数
普通数据类型的注入
private String name; private Integer age; public void setName(String name) { this.name = name; } public void setAge(Integer age) { this.age = age; } public void save(){ System.out.println(name+"==="+age); System.out.println("save Running....."); }
然后在配置中声明参数 applicationContext.xml
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" > <property name="name" value="zhangsan"/> <property name="age" value="20"/> </bean> <bean id="userService" class="com.springTestTwo.service.Impl.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao"></constructor-arg> <!-- name 指的就是你的实现类中构造函数中的参数,我的userServiceImpl.java中的构造函数--> </bean>
userServiceImpl中的依旧不变
private UserDao userDao; public UserServiceImpl(UserDao userDao) { this.userDao = userDao; } public void save(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao) app.getBean("userDao"); userDao.save(); }
集合数据类型:
集合数据类型(List)的注入
在userDaoImpl实现类中设置list参数
private List<String> strList; public void setStrList(List<String> strList) { this.strList = strList; }
applicationContext.xml中
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" > <property name="strList"> <list> <value>1111</value> <value>aaaa</value> <value>bbbb</value> </list> </property> </bean>
集合数据类型(Map)的注入
在userDaoImpl实现类中设置map参数
userDaoImpl.java
private Map<String, User> userMap; public Map<String, User> getUserMap() { return userMap; } public void setUserMap(Map<String, User> userMap) { this.userMap = userMap; }
然后创建User.java
private String name; private Integer age; public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; }
applicationContext.xml
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" > <property name="userMap"> <map> <entry key="user1" value-ref="user1"></entry> <!--配置map的key和value--> <entry key="user2" value-ref="user2"></entry> </map> </property> </bean> <bean id="user1" class="com.springTestTwo.Dao.User"> <!--配置user用的bean对象 为user1--> <property name="name" value="laowang"/> <property name="age" value="14"/> </bean> <bean id="user2" class="com.springTestTwo.Dao.User"><!--配置user用的bean对象 为user2--> <property name="name" value="laozhang"/> <property name="age" value="22"/> </bean>
propeties数据类型的注入:
userDaoImpl.java
private Properties properties; public Properties getProperties() { return properties; } public void setProperties(Properties properties) { this.properties = properties; }
applicationContext.xml中配置
<!-- 在Spring配置文件中配置UserDaoImpl接口的实现类--> <bean id="userDao" class="com.springTestTwo.Impl.UserDaoImpl" > <property name="properties"> <props> <prop key="p1">111</prop> <prop key="p2">2222</prop> <prop key="p3">3333</prop> </props> </property> </bean>
引入其他配置文件(分模块开发)
实际开发中,Spring的配置内容非常多,这就导致Spring配置很繁杂且体积很大,所以,可以将部分配置拆解到其
他配置文件中,而在Spring主配置文件通过import标签进行加载
<import resource="applicationContext-xxx.xml"/>
上面我们可以看到如果有很多的类对象要创建bean的话 我们都放在一个配置中,那样会很补友好 所以分模块化开发,然后引用才是王道
使用import来导入
例如我有两个配置 我可以在applicationContext.xml中导入applicationContext-User.xml
<import resource="applicationContext-User.xml"/>
spring的重点配置
<bean>标签 id属性:在容器中Bean实例的唯一标识,不允许重复 class属性:要实例化的Bean的全限定名 scope属性:Bean的作用范围,常用是Singleton(默认)和prototype <property>标签:属性注入 name属性:属性名称 value属性:注入的普通属性值 ref属性:注入的对象引用值 <list>标签 <map>标签 <properties>标签 <constructor-arg>标签 <import>标签:导入其他的Spring的分文件
Spring的相关API
ApplicationContext的继承体系
applicationContext:接口类型,代表应用上下文,可以通过其实例获得 Spring 容器中的 Bean 对象
ApplicationContext的实现类
1)ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种 2)FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。 3)AnnotationConfigApplicationContext 当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。
ClassPathXmlApplicationContext和FileSystemXmlApplicationContext的使用差不多只不过是获取文件的位置不同
下面是FileSystemXmlApplicationContext的使用
public static void main(String[] args) { // ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); ApplicationContext app1 = new FileSystemXmlApplicationContext("E:\\Tools\\Java\\Cods\\Spring\\SptingTestTwo\\SptingAopTestOne\\src\\main\\resources\\applicationContext.xml"); UserService userService = (UserService) app1.getBean("userService"); // 直接获取UserServiceImpl这个实现类 userService.save(); }
getBean()方法使用
public Object getBean(String name) throws BeansException { assertBeanFactoryActive(); return getBeanFactory().getBean(name); } public <T> T getBean(Class<T> requiredType) throws BeansException { assertBeanFactoryActive(); return getBeanFactory().getBean(requiredType); }
其中,当参数的数据类型是字符串时,表示根据Bean的id从容器中获得Bean实例,返回是Object,需要强转。
当参数的数据类型是Class类型时,表示根据类型从容器中匹配Bean实例,当容器中相同类型的Bean有多个时,则
此方法会报错
public class UserServiceDemo { public static void main(String[] args) { // ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); ApplicationContext app1 = new FileSystemXmlApplicationContext("E:\\Tools\\Java\\Cods\\Spring\\SptingTestTwo\\SptingAopTestOne\\src\\main\\resources\\applicationContext.xml"); UserService userService1 = (UserService) app1.getBean("userService"); // 直根据Bean的id从容器中获得Bean实例 这种当你的配置文件中有相同的实现类是可以使用 UserService userService2 = app1.getBean(UserService.class); // 数据类型是Class类型时获取,当你的配置文件中有相同的实现类是不可以使用 userService1.save(); userService2.save(); }
.