Spring : 就是一个轻量级的控制反转(IOC) 和面向切面编程的(AOP)的框架
Spring 容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用时再从Ioc容器中取出需要的对象
Ioc 本质
控制反转 IoC(inversion of control)是一种设计思想,DI(依赖注入)是实现IOC的一种方法。没有IoC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候,Bean 的定义信息是和实现分离的,而采用注解方式可以把两者合为一体,Bean 的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方生产获取特定对象的方式,在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入(dependency injection DI)
控制反转:
控制 : 谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是由Spring 来创建的
反转 : 程序本身不创建对象,而变成被动的接收对象
依赖注入 : 利用set方法来进行注入的
IOC是一种编程思想,由主动的编程变成被动的接收
要实现不同的操作,只需要在XML配置中进行修改,
所谓的IOC 一句话: 对象由Spring 来创建,管理,装配!
案例1:
dao层:
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
xml配置:
<!--使用Spring 来创建对象, 在Spring 这些都成为Bean
类型 变量名 = new 类型();
Hello hello = new Hello();
id = 变量名
class = new 的对象
property 相当于给对象中的属性设置一个值
-->
<bean id="hello" class="com.kuang.pojo.Hello">
<property name="str" value="你好Spring"/>
</bean>
测试类:
public static void main(String[] args) {
//使用xml配置 必有的new对象 固定的 ClassPathXmlApplicationContext
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//对象现在都在Spring中管理,我们要使用,直接去里面取出来就可以!
Hello bean = (Hello) context.getBean("hello");
System.out.println(bean.toString());
}
案例2:
dao 层 接口:
public interface UserDao {
void getUser();
}
dao层实现类:
public class UserDaoMysqlImpl implements UserDao {
public void getUser() {
System.out.println("Mysql-获取用户数据");
}
}
业务层接口:
public interface UserService {
void getUser();
}
业务层实现类:
public class UserServiceImpl implements UserService {
//业务层调用dao层
/**
* private UserDao userDao = new UserDaoMysqlImpl();
* 之前程序是主动创建对象,控制全在程序员手里,
* 使用set 注入后,程序不在具有主动性,而是变成被动的接收对象
*
* 我们 不用在管理对象的创建了,系统的耦合性降低,更加专注在业务的实现上,ioc 原型
*/
private UserDao userDao ;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
beans.xml配置:
//创建了一个UserDaoMysqlImpl对象,变量名为mysqlImpl
<bean id="mysqlImpl" class="com.kuang.dao.UserDaoMysqlImpl" />
//创建了一个UserDaoOrcalImpl对象,变量名为orcalImpl
<bean id="orcalImpl" class="com.kuang.dao.UserDaoOrcalImpl" />
//创建了一个UserServiceImpl对象,变量名为serviceImpl
<bean id="serviceImpl" class="com.kuang.service.UserServiceImpl">
<!--
ref:引用Spring容器中创建好的对象
value:具体的值,基本数据类型
-->
<property name="userDao" ref="mysqlImpl"/>
</bean>
测试类:
//获取 applicationcontext; 拿到spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手,天下我有,需要什么 就直接get什么!
UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("serviceImpl");
serviceImpl.getUser();
有参案例:
dao层:
public class User {
private String name;
public User(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name=" + name);
}
}
xml配置:
<!-- 无参构造方法注入 -->
<!-- <bean id="user" class="com.kuang.pojo.User">-->
<!-- <property name="name" value="大娃"/>-->
<!-- </bean>-->
<!-- 有参构造方法注入 index方式(下标赋值) -->
<!-- <bean id="user" class="com.kuang.pojo.User">-->
<!-- <constructor-arg index="0" value="-有参构造"/>-->
<!-- </bean>-->
<!-- 有参构造方法注入 直接通过参数名赋值 (最常用) -->
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg name="name" value="-name方式"/>
</bean>
测试类:
public class MyTest {
public static void main(String[] args) {
//获取到容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
}
}
总结: 在配置文件加载的时候,容器中管理的对象就已经被初始化了!