Spring-IOC(1)

耦合

在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计
应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个
准则就是高内聚低耦合

我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的

public class UserServiceImpl implements UserService {
    private UserDao userDao= new UserDao();
    pub User getUser(){
        return userDao.getUser();
    }
}

上面的代码表示：业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译
将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

解耦

当是我们使用 jdbc 时，是通过反射来注册驱动的，代码如下：

Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串

此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运
行就不要想了，没有驱动不可能运行成功的）。

工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的
方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

控制反转 Inversion Of Control

原来,我们在获取对象时，都是采用 new 的方式。是主动的。

现在,我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

明确 ioc 的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)

使用IOC解决程序耦合

1.准备spring的jar包

https://spring.io/

2.创建持久层业务层的接口和实现类

public interface IAccountDao {
    void saveAccount();
}

public class AccountDaoImpl implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

public interface IAccountService {
    void saveAccount();
}

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();// 此处的依赖关系有待解决
    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

3.配置XML文件(或使用注解)，让Spring管理Bean

<?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">
</beans>

    <!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
        id 属性：对象的唯一标识。
        class 属性：指定要创建对象的全限定类名
    -->
    <!-- 配置 service -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    </bean>
    <!-- 配置 dao -->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>

4.测试配置是否成功

public static void main(String[] args) {
    //1.使用 ApplicationContext 接口，就是在获取 spring 容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //2.根据 bean 的 id 获取对象
    IAccountService aService = (IAccountService) ac.getBean("accountService");
    System.out.println(aService);
    IAccountDao aDao = (IAccountDao) ac.getBean("accountDao");
    System.out.println(aDao);
}

XML配置的细节

BeanFactory 和和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：
创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。

ApplicationContext接口的实现类

ClassPathXmlApplicationContext ：它是从类的根路径下加载配置文件推荐使用这种
FileSystemXmlApplicationContext ：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

IOC中bean标签和管理对象细节

bean 标签

作用:用于配置对象并让 spring 来创建
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性:
id：给对象在容器中提供一个唯一标识,用于获取对象
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数
scope：指定对象的作用范围

singleton :默认值，单例的.
prototype :多例的.
request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么
globalSession 相当于 session

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

bean 的作用范围和生命周期

单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：

对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope="prototype"

每次访问对象时，都会重新创建对象实例。

生命周期：

对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

spring 的依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现

构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入

public class AccountServiceImpl implements IAccountService {
    private String name;
    private Integer age;
    private Date birthday;
    public AccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
    @Override
    public void saveAccount() {
        System.out.println(name+","+age+","+birthday);
    }
}

<!-- 使用构造函数的方式，给 service 中的属性传值
要求：
类中需要提供一个对应参数列表的构造函数。
涉及的标签：
constructor-arg
属性：
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和 String 类型
ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <constructor-arg name="name" value=" 张三 "></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>

set 方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法

public class AccountServiceImpl implements IAccountService {
    private String name;
    private Integer age;
    private Date birthday;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public void saveAccount() {
        System.out.println(name+","+age+","+birthday);
    }
}

<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：
property 属性：
    name：找的是类中 set 方法后面的部分
    ref：给属性赋值是其他 bean 类型的
    value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="name" value="test"></property>
    <property name="age" value="21"></property>
    <property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

使用 p 名称空间注入数据（还是调用 set 方法）

<bean id="accountService"
    class="com.itheima.service.impl.AccountServiceImpl4"
    p:name="test" p:age="21" p:birthday-ref="now"
</bean>

注入集合属性

给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。例如，List,Set,Map,Properties

public class AccountServiceImpl implements IAccountService {
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;
    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }
    public void setMyList(List<String> myList) {
        this.myList = myList;
    }
    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }
    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }
    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }
    @Override
    public void saveAccount() {
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

<!-- 注入集合数据
List 结构的：
array,list,set
Map 结构的
map,entry,props,prop
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
    <!-- 给数组注入数据 -->
    <property name="myStrs">
    <set>
        <value>AAA</value>
        <value>BBB</value>
        <value>CCC</value>
    </set>
    </property>
    <!-- 注入 list 集合数据 -->
    <property name="myList">
    <array>
        <value>AAA</value>
        <value>BBB</value>
        <value>CCC</value>
    </array>
    </property>
    <!-- 注入 set 集合数据 -->
    <property name="mySet">
    <list>
        <value>AAA</value>
        <value>BBB</value>
        <value>CCC</value>
    </list>
    </property>
    <!-- 注入 Map 数据 -->
    <property name="myMap">
    <map>
        <entry key="testA" value="aaa"></entry>
        <entry key="testB">
        <value>bbb</value>
        </entry>
    </map>
    </property>
    <!-- 注入 properties 数据 -->
    <property name="myProps">
    <props>
        <prop key="testA">aaa</prop>
        <prop key="testB">bbb</prop>
    </props>
    </property>
</bean>

posted @ 2020-04-09 10:39 tianqibucuo 阅读(128) 评论(0) 收藏举报

刷新页面返回顶部

tianqibucuo

Get busy living, or get busy dying

Spring-IOC(1)

耦合

解耦

工厂模式解耦

控制反转 Inversion Of Control

使用IOC解决程序耦合

1.准备spring的jar包

2.创建持久层业务层的接口和实现类

3.配置XML文件(或使用注解)，让Spring管理Bean

4.测试配置是否成功

XML配置的细节

BeanFactory 和和 ApplicationContext 的区别

ApplicationContext接口的实现类

IOC中bean标签和管理对象细节

bean 的作用范围和生命周期

spring 的依赖注入

构造函数注入

set 方法注入

使用 p 名称空间注入数据（还是调用 set 方法）

注入集合属性

公告

tianqibucuo

Get busy living, or get busy dying

Spring-IOC(1)

耦合

解耦

工厂模式解耦

控制反转 Inversion Of Control

使用IOC解决程序耦合

1.准备spring的jar包

2.创建持久层业务层的接口和实现类

3.配置XML文件(或使用注解)，让Spring管理Bean

4.测试配置是否成功

XML配置的细节

BeanFactory 和 和 ApplicationContext 的区别

ApplicationContext接口的实现类

IOC中bean标签和管理对象细节

bean 的作用范围和生命周期

spring 的依赖注入

构造函数注入

set 方法注入

使用 p 名称空间注入数据（还是调用 set 方法）

注入集合属性

公告

BeanFactory 和和 ApplicationContext 的区别