Spring中依赖注入的两种方式

1. 构造注入
2. setter注入

①数据访问层

package edu.tjdz.dao;

import edu.tjdz.entity.Student;
//定义接口

public interface IUniversityDao {
	
	String selectStuInfo(Student student);
	
	//得到学生学校信息
	String getStuSchool();

}

//ImpI类
package edu.tjdz.dao.ImpI;

import edu.tjdz.dao.IUniversityDao;
import edu.tjdz.entity.Student;

public class DZXXImpI implements IUniversityDao {
	
	public DZXXImpI() {
		//System.out.print("DDXX无参构造执行");
	}
	
	@Override
	public String selectStuInfo(Student student) {
		//使用String类的format方法格式化代码
		//使用指定的格式字符串和参数返回格式化字符串。
		String stuInfo = String.format("学生的姓名:%s,学生的年龄:%s,更多信息:%s",
				student.getStuname(),student.getStuage(),student.getStumostInfo());
		return stuInfo;
	}
	
	public String getStuSchool() {
		return "天津电子信息职业技术学院";
	}

}

package edu.tjdz.dao.ImpI;

import edu.tjdz.dao.IUniversityDao;
import edu.tjdz.entity.Student;

public class TsinghuaImpI implements IUniversityDao{

	@Override
	public String selectStuInfo(Student student) {
		//使用String类的format方法格式化代码
		//使用指定的格式字符串和参数返回格式化字符串。
		String stuInfo = String.format("学生的姓名:%s,学生的年龄:%s,更多信息:%s",
						student.getStuname(),student.getStuage(),student.getStumostInfo());
		return stuInfo;
	}

	@Override
	public String getStuSchool() {
		return "清华大学";
	}

}

②实体类

package edu.tjdz.entity;

import java.util.List;

public class Student {
	
	private String stuname;
	private Integer stuage;
	List<String> stumostInfo;
	
	/**
	 * 第一种方式：使用setter注入
	 * 1.需要有无参构造
	 * 2.需要有setter方法
	 */
	public Student() {}
	
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}

	public void setStuage(Integer stuage) {
		this.stuage = stuage;
	}

	public void setStumostInfo(List<String> stumostInfo) {
		this.stumostInfo = stumostInfo;
	}
	
	/**
	 *  第二种方式：构造注入
	 *  提供有参构造
	 */
	public Student(String stuname, Integer stuage, List<String> stumostInfo) {
		this.stuname = stuname;
		this.stuage = stuage;
		this.stumostInfo = stumostInfo;
	}


	/**
	 * 提供getter方法便于获取学生信息
	 */
	public String getStuname() {
		return stuname;
	}

	public Integer getStuage() {
		return stuage;
	}

	public List<String> getStumostInfo() {
		return stumostInfo;
	}

	/**
	 *   重写toString()：防止输出内存空间的引用地址
	 */
	@Override
	public String toString() {
		return "Student [ stuname=" + stuname + ", stuage=" + stuage + ", stumostInfo="
				+ stumostInfo + "]";
	}
	
}

③Service层

package edu.tjdz.service;

import edu.tjdz.entity.Student;

public interface IStudentService {
	
	public void showStuInfo(Student stu);

}

//实现类
package edu.tjdz.service.ImpI;

import edu.tjdz.dao.IUniversityDao;
import edu.tjdz.entity.Student;
import edu.tjdz.service.IStudentService;

public class StudentServiceImpI implements IStudentService {

	//面向接口编程，实现解耦合，高扩展
	private IUniversityDao dao;
	
	/**
	 * 第一种方式：使用setter注入
	 * 1.有参数构造方法
	 * 2.setter方法
	 */
	public StudentServiceImpI() {}
	
	public void setDao(IUniversityDao dao) {
		this.dao = dao;
	}
	
	/**
	 * 第二种注入方式：使用构造注入
	 * 1.提供构造方法
	 */
	public StudentServiceImpI(IUniversityDao dao) {
		this.dao=dao;
	}

	@Override
	public void showStuInfo(Student stu) {
		//获取学校
		String school = dao.getStuSchool();
		//获取学生个人信息，通过setter，getter
		String msg = dao.selectStuInfo(stu);
		System.out.println("学校："+school+"------>"+""+msg);
	}

}

④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-4.3.xsd"> 

 	
	<!-- 
		第一种方式：使用setter注入  
	-->
	<!-- 声明学生对象 -->
	<bean id="stu" class="edu.tjdz.entity.Student">
		<property name="stuname" value="王佳伟"/>
		<property name="stuage" value="20"/>
		<property name="stumostInfo">
			<list>
				<value>"班级：软件S20-4班"</value>
				<value>"学号：05"</value>
			</list>
		</property>
	</bean>
	<!-- 声明学校对象 -->
	<bean id="dDXXSchool" class="edu.tjdz.dao.ImpI.DZXXImpI"/>
	<!-- 声明StudentServiceImpI对象 -->
	<bean id="stuService" class="edu.tjdz.service.ImpI.StudentServiceImpI">
		<property name="dao" ref="dDXXSchool"/>
	</bean>
</beans>



<?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-4.3.xsd"> 


	<!-- 
		第二种方式：使用构造注入
	 -->
	 
	 <bean id="conStu" class="edu.tjdz.entity.Student">
	 	<constructor-arg index="0" value="某某某" />
	 	<constructor-arg index="1" value="20"/>
	 	<constructor-arg index="2">
	 		<list>
	 			<value>"班级：软件S20-4班"</value>
	 			<value>"学号：99"</value>
	 		</list>
	 	</constructor-arg>
	 </bean>
	 
	 <!-- 声明学校对象 -->
	 <bean id="TsinghuaSchool" class="edu.tjdz.dao.ImpI.TsinghuaImpI"/>
	 
	<!-- 声明StudentServiceImpI对象 -->
	<bean id="conStuService" class="edu.tjdz.service.ImpI.StudentServiceImpI">
		<constructor-arg index="0" ref="TsinghuaSchool"/>
	</bean>
	
</beans>

spring的第一个核心技术：控制反转

spring的第一个核心功能 ioc

IoC（Inversion of Control）：控制反转，是一个理论，概念，思想。
    描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现，也就是对象的创建是有其它外部资源完成的。

控制：创建对象啥，对象的属性赋值，对象之间的关系管理。
反转：把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现，由容器代替开发人员管理对象。创建对象，
            给属性赋值。

正转：由开发人员在代码中，使用new 构造方法创建对象，开发人员主动管理对象。
        public static void main(String [] args){
            Stduent student = new Student();    // 在对象中，创建对象。--正转。
        }

容器：是一个服务器软件，一个框架（Spring）

为什么要是用IoC：目的就是减少对代码的改动，也能实现不同的功能。实现解耦合。

java中创建对象有哪些方式：
    1.构造方法，new Student()
    2.反射
    3.序列化
    4.IoC：容器创建对象 
    5.动态代理

ioc的体现：
    servlet  1：    创建类继承HttpServlet
                     2：创建web.xml注册servlet，使用<servlet-name>myservlet</servlet-name>
                                                                                     <servlet-class>edu.tjdz.controller.MyServlet</servlet-class>

                     3：没有创建Servlet对象，没有 MyServlet myservlet = new MyServelt()

                     4：Servlet 是Tomcat服务器给你创建的。Tomcat也称为容器。
                             Tomcat作为容器：里面存放的有Servlet对象，Listener，Filter对象。

IoC的技术实现：
    DI 是 ioc的技术实现，
    DI（Dependency Injection）：依赖注入，只需要在程序中提供要使用的对象名称就可以，至于对象如何在容器中创建，
                                                            赋值，查找都由容器内部实现。

Spring是使用的DI实现了IoC的功能，Spring底层创建对象，使用的是反射机制。

Spring是一个容器，管理对象，给属性赋值，底层是反射创建对象。

spring-context 和 spring-webmvc是spring的两个模块

spring-context：是ioc功能的，创对象的。
spring-webmvc做web开发使用的，是servlet的升级。
spring-webmvc中也会用到spring-context中创建对象功能的。