再识Spring

依赖注入 Dependency Injection

什么是依赖注入？简单的说就是给对象的属性赋值，依赖注入是控制反转（ioc）的具体实现
空指针异常 是指 null.属性或者null.方法（"“空串.属性或”".方法不会报空指针异常，因为""是一个空的字符串）
创建三个类：UserServlet、UserService、Test
在UserServlet里创建UserService对象，但是不赋值 private UserService userService;
这样在由userService对象调用它的方法是就会报空指针异常（因为userService为null）
依赖指的是UserServlet依赖UserService，注入指的是给UserServlet里的userService赋值，这个赋的值也是一个UserService的实例化对象
怎么赋的值——>通过调用set方法赋值
bean的id是唯一标识符
ref是reference的缩写，引用；property 属性
在applicationContext.xml创建bean

<bean class="com.weilinyang.service.UserService" id="us"></bean>
<bean class="com.weilinyang.web.UserServlet">
	<property name="userService" ref="us"></property>
</bean>

public class UserServlet {
	private UserService userService;
	
	public void success() {
		userService.success();
	}

	public UserService getUserService() {
		return userService;
	}

	public void setUserService(UserService userService) {
		this.userService = userService;
	}
	
	
}

public class UserService {

	public void success() {
		System.out.println("这是UserService里的success方法");
	}

}

public class SpringTest {
	@Test
	public void test() {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServlet userServlet = context.getBean(UserServlet.class);
		userServlet.success();
	}
}

分模块配置

在applicationContxt.xml中导入其他beans.xml

内部bean与外部bean

内部bean：在某个bean标签内部定义的bean对象，内部bean只能某个对象（上一层bean）的某个属性（property ）引用

<bean id="userServlet01" class="com.weilinyang.web.UserServlet">
    <!-- 引用的内部bean -->
    <property name="userService" >
      <bean id="userService01" class="com.weilinyang.service.UserService"></bean>
    </property>
 </bean>

外部bean：直接在beans标签内部直接定义的bean对象，外部bean可以被多个bean对象引用

<bean id="user01" class="com.weilinyang.service.UserService"></bean>
  
<bean id="userServlet02" class="com.weilinyang.web.UserServlet">
    <!-- 引用的外部bean -->
   <property name="userService" ref="user01"/>
</bean>

创建对象的三种方式

通过构造器的方式【无参构造器、有参构造器】

public class Animal {
	private Integer id;
	private String name;
	public Animal() {
	  System.out.println("Animal的无参构造器");
	}
	public Animal(Integer id) {
		super();
		this.id = id;
	}
	public Animal(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Animal [id=" + id + ", name=" + name + "]";
	}
}

<!--  通过构造器的方式【无参构造器、有参构造器】 -->
  <bean class="com.weilinyang.pojo.Animal">
     <!-- 该标签可以给构造器的参数赋值,name属性指定构造器的参数名,value属性表示给赋的值 -->
     <constructor-arg name="id" value="10"></constructor-arg>
     <constructor-arg name="name" value="张三"></constructor-arg>
  </bean>

通过静态工厂:指的是通过类的静态方法得到的对象!【了解】

public class StaticFactory {
	public static Animal getAnimal() {
		Animal animal = new Animal(12,"猪八戒");
		return animal;
	}
}

<!-- 静态工厂:通过调用类的静态方法得到的对象，factory-method指定调用哪个静态方法，得到的对象是：Aimal对象 -->
  <bean id="animal01" class="com.weilinyang.pojo.StaticFactory" factory-method="getAnimal"></bean>

通过实例工厂:指的是通过类对象的普通方法得到的对象!【了解】

public class InstanceFactory {
	public Animal getAnimal() {
		Animal animal = new Animal(13,"春光灿烂猪八戒");
		return animal;
	}
}

 <!-- 实例工厂:指的是通过类对象的普通方法得到的对象 -->
  <!-- 1.先创建类对象 -->
  <bean id="instanceFactory" class="com.weilinyang.pojo.InstanceFactory"></bean>
  <!-- 2.调用类对象的某个方法得到Animal对象,factory-bean:表示引用哪个对象，factory-method：表示引用哪个方法 -->
  <bean id="animal03" factory-bean="instanceFactory" factory-method="getAnimal"></bean>

给对象属性赋值

按值类型分为
　　值注入：普通类型属性赋值的时候，value属性
　　引用注入：给引用类型的属性赋值，ref属性
按注入方式分为：
　　构造器
　　set方法
　　　　property
　　　　p名称空间