IOC创建对象的方式
定义一个实体类
public class Hello {
private String str;
public Hello(String str){
this.str = str;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
1.使用无参构造创建对象,默认!
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用Spring来创建对象,/在Spring这些都称为Bean
类型 变量名=new 类型();
Hello hello=new Hello();
id =变量名
class =new 的对象
property 相当于给对象中的属性设置一个值!
-->
<bean id="hello" class="com.cd.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>
2.假设我们要使用有参构造创建对象
- 下标赋值
<bean id="user" class="com.cd.pojo.User">
<constructor-arg index="0" value="张三"/>
</bean>
- 类型
<bean id="user" class="com.cd.pojo.User">
<constructor-arg type="java.lang.String" value="张三"/>
</bean>
- 参数名
<bean id="user" class="com.cd.pojo.User">
<constructor-arg name="name" value="张三"/>
</bean>
测试代码
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User)context.getBean("user");
user.show();
}
}
总结: 在配置文件加载的时候,容器中管理的对象就已经初始化了!
Spring配置
别名:
Bean的配置
import
这个import,一般用于团队开发使用 ,他可以将多个配置文件,导入合并为一个。
假设,现在项目中有多个人开发,这三个人复制不同的类开发,不同的类需要注册在不同的bean中,我们可以利用import将所有的beans.xml合并为一个总的!
- 张三
- 李四
- 王五
- applicationContext.xml
使用的时候,使用总的配置就可以了
依赖注入
1- 构造器注入
前面已经说过了
2 - Set注入(重点)
- 依赖注入:Set注入
依赖:bean对象的创建依赖于容器
注入:bean对象中所有的属性,由容器来注入!
测试环境搭建public class Address { private String address; public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public String toString() { return "Address{" + "address='" + address + '\'' + '}'; }
}
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> cars;
private Set<String> games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCars() {
return cars;
}
public void setCars(Map<String, String> cars) {
this.cars = cars;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", cars=" + cars +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
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:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="com.cd.pojo.Address">
<property name="address" value="西安"/>
</bean>
<bean id="student" class="com.cd.pojo.Student">
<!--第一种普通值注入 value-->
<property name="name" value="秦疆"/>
<!--第二种,bean注入 ref-->
<property name="address" ref="address"/>
<!--数组-->
<property name="books" >
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--List-->
<property name="hobbys">
<list>
<value>唱歌</value>
<value>跳舞</value>
<value>编程</value>
<value>篮球</value>
</list>
</property>
<!--Map-->
<property name="cars">
<map>
<entry key="身份证" value="111111112233636"/>
<entry key="银行卡" value="42556644785956"/>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>LOL</value>
<value>NBA2KOnline</value>
<value>BOB</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="driver">20190525</prop>
<prop key="url">localhost:3306</prop>
<prop key="username">root</prop>
<prop key="password">root</prop>
</props>
</property>
</bean>
</beans>
测试代码:
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student =(Student) context.getBean("student");
System.out.println(student.toString());
}
拓展方式注入
我们可以使用p命名空间和c命名空间注入
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
<?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:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入,可以直接注入属性的值:property-->
<bean id="user" class="com.cd.pojo.User" p:name="张三" p:age="18"/>
<!--c命名空注入: 通过构造器注入: construct-args -->
<bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="张三" scope="singleton"/>
</beans>
测试代码:
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user", User.class);
System.out.println(user);
}
注意: p命名空间个c命名空间不能直接使用,需要导入xml约束!
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
bean的作用域
1.单例模式(Spring默认的机制)
<bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="小明" scope="singleton"/>
每次从容器中get的时候,都是同一个对象
2.原型模式:每次从容器中get的时候,都会产生一个新的对象!
<bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="zhangsan" scope="prototype"/>
3其余的request,session,application这些个只能在web开发中使用到
**7.Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中有3种装配的方式
- 在xml中显示的装配
- 在java中显示装配
- 隐式的自动装配bean[重要]
测试环境搭建:一个人有两个宠物
public class Cat {
public void shout(){
System.out.println("miao ~");
}
}
public class Dog {
public void shout(){
System.out.println("wang~");
}
}
public class People {
//如果显示的定义了Autowired的required属性为false,说明这个对象可以为null,否则不允许为空
@Autowired
@Qualifier(value="cat1")
private Cat cat;
@Autowired
@Qualifier(value="dog1")
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
7.2 ByName自动装配
7.3 ByType自动装配
public class MyTest {
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
小结:
- byName的时候,需要保证所有的bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致
- bytype的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入属性的类型一致
7.4使用注解实现自动装配
jdk1.5支持注解,Spring2.5就支持注解了!
要想使用注解须知:
1.导入约束: context约束
2.配置注解支持:context:annotation-config/
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--开启注解支持-->
<context:annotation-config/>
</beans>
Autowire
直接在属性上面使用即可,也可以在set方法上使用!
使用Autowire我们可以不用编写Set方法了,前提是你这个自动装配的属性在IOC(Spring)容器中存在,且符合名字byname(先找byType,然后再找byname)
科普:
如果@Autowire自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowire】完成的时候,我们可以使用@Qualifier(value=“xxx”)去配置@Autowire的使用,指定一个唯一的bean 对象注入!
public class People {
//如果显示的定义了Autowired的required属性为false,说明这个对象可以为null,否则不允许为空
@Autowired
@Qualifier(value="cat1")
private Cat cat;
@Autowired
@Qualifier(value="dog1")
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
@Resource注解
小结
@Autowire和@Resource之间的区别:
- 都是用来自动装配的,都可以放在属性字段上面
- @Autowire通过byType的方式实现,而且必须要求这个对象存在!【常用】
- @Resource默认通过byname的方式实现,如果找不到名字,则通过byType实现,如果两个都找不到的情况下,就会报错【常用】
- 执行顺序不同:@Autowire通过byType的方式实现,@Resource默认通过byname的方式实现
8.使用注解开发
在Spring4之后,要使用注解开发,必须要保证aop的包导入了
使用注解需要导入context约束,增加注解的支持!
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--指定要扫描的包,这个包下的注解就会生效-->
<context:component-scan base-package="com.cd"/>
<!--提供注解支持-->
<context:annotation-config/>
</beans>
2.属性如何注入
3.衍生的注解
@Component有几个衍生的注解,我们在web开发中,会按照mvc三层架构分层
- dao @Repository
- service @Service
- controller @Controller
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
4.自动装配
//等价于 <bean id="user" class="com.cd.pojo.User"/>
//@Component 意思就是组建的意思
@Component
public class User {
//相当于 <property name="name" value="雨神"/>
@Value("雨神")
public String name;
}
6.小结
xml与注解:
- xml更加万能,适用于任何场合,维护简单方便
- 注解 不是自己的类使用不了,维护相对复杂!
xml与注解最佳实践:
- xml用来管理bean;
- 注解只用来完成属性的注入
- 我们在使用的过程中,只需要注意一个问题:必须让注解生效,就需要开启注解的支持
<!--指定要扫描的包,这个包下的注解就会生效-->
<context:component-scan base-package="com.cd"/>
<context:annotation-config/>
使用java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给java来做!
JavaConfig是Spring的一个子项目,在Spring4之后,他就成为了一个核心功能
实体类
配置文件
测试类
这种纯java的配置方式,在springboot中随处可见