Spring学习笔记01-控制反转IOC&依赖注入DI

最新推荐文章于 2021-01-25 12:50:50 发布
最新推荐文章于 2021-01-25 12:50:50 发布
阅读量725 收藏 1
点赞数
分类专栏： SSM JAVA WEB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40046426/article/details/104189025
版权
JAVA WEB 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
SSM
11 篇文章 0 订阅
订阅专栏

Spring

文章目录

控制反转 IOC

程序的耦合和解耦

  • 耦合: 程序间的依赖关系.在开发中,应该做到解决编译期依赖,即编译期不依赖,运行时才依赖.
  • 解耦的思路: 使用反射来创建对象,而避免使用new关键字,并通过读取配置文件来获取要创建的对象全限定类名

使用Spring解决程序耦合

准备工作
  1. 使用maven引入依赖，pom.xml如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yll</groupId>
    <artifactId>Spring01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

</project>
  1. 在resources下创建bean的配置文件bean.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountDao" class="com.yll.dao.impl.AccountDaoImpl"></bean>
    <bean id="accountService" class="com.yll.service.impl.AccountServiceImpl"></bean>
</beans>
  1. 修改表现层代码，通过Spring创建对象
/***
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
//        IAccountService as =  new AccountServiceImpl();
//        as.saveAccount();
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);
        System.out.println(as);
        System.out.println(adao);
    }

}
使用xml配置文件实现IOC
  • 获取spring的IOC核心容器，并根据id获取对象
ApplicationContext方式

  • 特点：

    • 读取完配置文件，立马创建对象等待使用
    • 单例对象使用
      • 我们实际开发中使用这个，因为加载策略会随配置文件改变

  • ApplicationContext的三个常用实现类

  1. ClassPathXmlApplicationContext:可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在，加载不了
  2. FileSystemXmlApplicationContext:可以加载磁盘任意路径下的配置文件（必须有访问权限）
  3. AnnotationConfigApplicationContext:用于读取注解创建容器
  • 核心容器的两个接口引发出的问题：
    • ApplicationContext： 单例对象使用
      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。一读取完配置文件马上就创建配置文件中配置的对象。
    • BeanFactory： 多例对象使用
      它再构建核心容器时，创建对象采取的策略是采用延迟加载的方式。什么时候根据id获取对象了，什么时候才真正创建对象
bean标签
  • 作用: 配置托管给spring的对象,默认情况下调用类的无参构造函数,若果没有无参构造函数则不能创建成功
  • 属性:
    • id: 指定对象在容器中的标识,将其作为参数传入getBean()方法可以获取获取对应对象.
    • class: 指定类的全类名,默认情况下调用无参构造函数
    • scope: 指定对象的作用范围,可选值如下
      • singleton: 单例对象,默认值
      • prototype: 多例对象
      • request: 将对象存入到web项目的request域中
      • session: 将对象存入到web项目的session域中
      • global session: 将对象存入到web项目集群的session域中,若不存在集群,则global session相当于session
    • init-method：指定类中的初始化方法名称,在对象创建成功之后执行
    • destroy-method：指定类中销毁方法名称,对prototype多例对象没有作用,因为多利对象的销毁时机不受容器控制
bean作用范围
  • scope="Singleton"单例对象
    • 作用范围：每个应用只有一个该对象的实例,它的作用范围就是整个应用
    • 生命周期: 单例对象的创建与销毁和容器的创建与销毁时机一致
      • 出生: 当应用加载,创建容器时,对象就被创建
      • 活着: 只要容器存在,对象一直活着
      • 死亡: 当应用卸载,销毁容器时,对象就被销毁
  • scope="prototype"多例对象
    • 作用范围: 每次访问对象时,都会重新创建对象实例.
    • 生命周期: 多例对象的创建与销毁时机不受容器控制
      • 出生: 当使用对象时,创建新的对象实例
      • 活着: 只要对象在使用中,就一直活着
      • 死亡: 当对象长时间不用时,被 java 的垃圾回收器回收了
创建bean的三种方式
  1. 使用默认构造函数创建。
    在spring配置文件中使用Bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，如果此类中没有默认构造函数，则对象无法创建。
<bean id="accountService" class="com.yll.service.impl.AccountServiceImpl"></bean>
  • 必须要有AccountServiceImpl构造函数
/**
 * 账户业务层实现类
 * */
public class AccountServiceImpl implements IAccountService {
    public AccountServiceImpl(){
        System.out.println("accountServiceImpl构造了");
    }
    
    public void saveAccount() {
        System.out.println("accountService……");
    }

    public void init() {
        System.out.println("init……");
    }

    public void destory()
    {
        System.out.println("destory……");
    }

}
  1. 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象。并存入spring容器）
  • 创建一个工厂
public class InstanceFactory {
    public IAccountService getAccountService(){
        return new AccountServiceImpl();
    }
}

<bean id="instanceFactory" class="com.yll.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
  • factory-bean属性：指定实例工厂的id
  • factory-method属性：指定实例工厂中生产对象的方法
  1. 使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象，并存入spring容器)
  • 创建一个静态工厂 (静态方法不需要实例)
public class StaticFactory {
    public static IAccountService getAccountService(){
        return new AccountServiceImpl();
    }
}

<bean id="accountService" class="com.yll.factory.StaticFactory" factory-method="getAccountService"></bean>
使用注解实现IOC
用于创建对象的注解

这些注解的作用相当于bean.xml中的<bean>标签

  • @Component: 把当前类对象存入spring容器中,其属性如下:
    value: 用于指定当前类的id. 不写时默认值是当前类名,且首字母改小写

  • @Controller: 将当前表现层对象存入spring容器中

  • @Service: 将当前业务层对象存入spring容器中

  • @Repository: 将当前持久层对象存入spring容器中

    @Controller,@Service,@Repository注解的作用和属性与@Component是一模一样的,可以相互替代,它们的作用是使三层对象的分别更加清晰.

用于注入数据的注解

这些注解的作用相当于bean.xml中的<property>标签

  • @Autowired: 自动按照成员变量类型注入.
    • 注入过程
      • 当spring容器中有且只有一个对象的类型与要注入的类型相同时,注入该对象.
      • 当spring容器中有多个对象类型与要注入的类型相同时,使用要注入的变量名作为bean的id,在spring容器查找,找到则注入该对象.找不到则报错.
    • 出现位置: 既可以在变量上,也可以在方法上
    • 细节: 使用注解注入时,set方法可以省略
  • @Qualifier: 在自动按照类型注入的基础之上,再按照bean的id注入.
    • 出现位置: 既可以在变量上,也可以在方法上.注入变量时不能独立使用,必须和@Autowired一起使用; 注入方法时可以独立使用.
    • 属性:
      • value: 指定bean的id
  • @Resource: 直接按照bean的id注入,它可以独立使用.独立使用时相当于同时使用@Autowired和@Qualifier两个注解.
    • 属性:
      • name: 指定bean的id
  • @Value: 注入基本数据类型和String类型数据
    • 属性:
      • value: 用于指定数据的值,可以使用Spel表达式(${表达式})
用于改变作用范围的注解

这些注解的作用相当于bean.xml中的<bean>标签的scope属性

  • Scope:指定bean的作用范围
    • 属性
      • value: 用于指定作用范围的取值"singleton","prototype","request","session","globalsession"
和生命周期相关的注解

这些注解的作用相当于bean.xml中的<bean>标签的init-method和destroy-method属性

  • @PostConstruct: 用于指定初始化方法
  • @PreDestroy: 用于指定销毁方法
一个例子

AccountServiceImpl类

@Service(value = "accountService")
@Scope(value = "singleton")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    @Qualifier(value = "accountDao")
    private IAccountDao accountDao;

    @PostConstruct
    public void init(){
        System.out.println("初始化方法调用");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("销毁方法调用");
    }

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

表现层

public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //根据id获取对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);
        IAccountService as2 = ac.getBean("accountService", IAccountService.class);
        System.out.println("是否为单例："+as.equals(as2));
        as.saveAccount();
        ac.close();
    }
}

bean.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，
    而是一个名称为context名称空间和约束中-->
    <context:component-scan base-package="com.yll"></context:component-scan>
</beans>

依赖注入 DI

什么是DI？

  • 依赖注入(Dependency Injection)是spring框架核心ioc的具体实现.

  • 通过控制反转IOC,我们把创建对象托管给了spring,但是代码中不可能消除所有依赖,例如:业务层仍然会调用持久层的方法,因此业务层类中应包含持久化层的实现类对象.我们使用框架通过配置的方式将持久层对象传入业务层,而不是直接在代码中new某个具体的持久化层实现类,这种方式称为依赖注入.

依赖注入的方法

  • 因为我们是通过反射的方式来创建属性对象的,而不是使用new关键字,因此我们要指定创建出对象各字段的取值.
构造函数注入
  • 使用的标签constructor-arg
  • 出现的位置：bean标签内部
  • 标签的属性：
    • type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
    • index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引位置0开始
    • name：用于指定给构造函数中指定名称的参数赋值
      以上三个用于指定给构造函数中的哪个参数赋
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的bean类型数据，指的就是在spring的ioc核心容器中出现的bean对象
  • 优势：
    获取bean对象时，注入操作时必须的操作，否则对象无法创建
  • 弊端：
    改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据也必须提供
  1. 为要注入的类添加字段和构造函数
/**
 * 账户业务层实现类
 * */
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;
    }

    public void saveAccount() {
        System.out.println("accountService……"+this.name+" "+this.age+" "+this.birthday);
    }
}
  1. 配置bean.xml
    <bean id="accountService" class="com.yll.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="test"/>
        <constructor-arg name="age" value="18" />
        <constructor-arg name="birthday" ref="now"/>
    </bean>
    <bean id="now" class="java.util.Date"></bean>
使用set注入（常用）
  • 涉及的标签：property
  • 出现的位置：bean标签内部
  • 标签的属性：
    • name：用于指定注入时所调用的set方法名称
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的bean类型数据，指的就是在spring的ioc核心容器中出现的bean对象
  • 优势：
    创建对象时没有明确的限制，可以直接使用默认构造函数
  • 弊端：
    如果某个成员必须有值，则获取对象时有可能set方法没有执行
  1. 为要注入的类添加Setter方法
/**
 * 账户业务层实现类
 * */
public class AccountServiceImpl2 implements IAccountService {
    //如果是经常变化的数据，并不适用于注入
    private String name;
    private Integer age;
    private Date birthday;

    public void setUserName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void saveAccount() {
        System.out.println("accountService……"+this.name+" "+this.age+" "+this.birthday);
    }
}
  1. 配置注入bean.xml
    <bean id="accountService2" class="com.yll.service.impl.AccountServiceImpl2">
        <property name="userName" value="testname"/>
        <property name="age" value="20"/>
        <property name="birthday" ref="now"/>
    </bean>
  • 这里的name属性是setXXX的XXX，不一定非要是属性名
复杂类型的注入/集合类型的注入
  • 集合字段及其对应的标签按照集合的结构分为两类: 相同结构的集合标签之间可以互相替换.
  • 只有键的结构:
    • 数组字段:<array>标签表示集合,<value>标签表示集合内的成员.
    • List字段: <list>标签表示集合,<value>标签表示集合内的成员.
    • Set字段: <set>标签表示集合,<value>标签表示集合内的成员.

其中<array>,<list>,<set>标签之间可以互相替换使用.

  • 键值对的结构:
    • Map字段: <map>标签表示集合,<entry>标签表示集合内的键值对,其key属性表示键,value属性表示值.
    • Properties字段: <props>标签表示集合,<prop>标签表示键值对,其key属性表示键,标签内的内容表示值.
      其中<map>,<props>标签之间 <entry>,<prop>标签之间可以互相替换使用.
  1. 为注入的类添加复杂类型（集合）字段
package com.yll.service.impl;

import com.yll.service.IAccountService;

import java.util.*;

/**
 * 账户业务层实现类
 * */
public class AccountServiceImpl3 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;
    }

    public void saveAccount() {
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(myMap);
        System.out.println(mySet);
        System.out.println(myProps);
    }
}
  1. 配置bean.xml
 <bean id="accountService3" class="com.yll.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAAA</value>
                <value>AssssAA</value>
                <value>AAAsssssA</value>
            </array>
        </property>
        <property name="mylist">
            <list>
                <value>list</value>
                <value>asssss</value>
                <value>ssss</value>
                <value>ylssssssss</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>ssssss</value>
                <value>sslllss</value>
                <value>ssmysetsss</value>
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="test1" value="test1Value"></entry>
                <entry key="test2" ><value>test2Value</value></entry>
            </map>
        </property>
        <property name="myProps">
            <props>
                <prop key="testPro1">ssasdss</prop>
                <prop key="testPro2">ssssadsasdss</prop>
            </props>
        </property>
    </bean>

案例

纯xml配置案例

  1. 编写业务层
    IAccountService.java
public interface IAccountService {

    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @param id
     * @return
     */
    Account findAccountById(Integer id);

    /**
     *  保存操作
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param id
     */
    void deleteAccount(Integer id);
}
  1. 业务层实现类 AccountServiceImpl.java，调用持久层对象的函数
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }

}
  1. 编写持久层
    IAccountDao.java
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return
     */
    Account findAccountById(Integer id);

    /**
     *  保存操作
     * @param account
     */
    void saveAccount(Account account);

    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 删除
     * @param id
     */
    void deleteAccount(Integer id);
}
  1. 持久层实现类AccountDaoImpl.java,完成数据库的操作
public class AccountDaoImpl implements IAccountDao {
    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    @Override
    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account", new BeanListHandler<>(Account.class));
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

    @Override
    public Account findAccountById(Integer id) {
        try {
            return runner.query("select * from account where id = ?", new BeanHandler<>(Account.class),id);
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

    @Override
    public void saveAccount(Account account) {
        try {
            runner.update("insert into account(name,money) values(?,?)",account.getName(),account.getMoney());
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

    @Override
    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

    @Override
    public void deleteAccount(Integer id) {
        try {
            runner.update("delete from account where id=?",id);
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

}
  1. 编写控制层
    Account.java
/**
 * 账户的实体类
 */
public class Account {
    private Integer id;
    private String name;
    private Float money;

    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;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
  1. 配置xml
    bean.xml,使用property代表需要提供setter方法注入
<?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">

    <!--配置Service-->
    <bean id="accountService" class="com.yll.service.impl.AccountServiceImpl">
        <!--注入dao-->
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!--配置Dao对象-->
    <bean id="accountDao" class="com.yll.dao.impl.AccountDaoImpl">
        <property name="runner" ref="queryRunner"/>
    </bean>
    <!--配置QueryRunner对象-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必要信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai"/>
        <property name="user" value="root"/>
        <property name="password" value="52151"/>
    </bean>
</beans>
  1. 编写测试类
/**
 * 使用junit单元测试配置
 */
public class AccountServiceTest {
    @Test
    public void testFindAll() {
        //1.获取容器
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        List<Account> accounts = as.findAllAccount();
        accounts.forEach(System.out::println);
    }
    @Test
    public void testFindOne() {
        //1.获取容器
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        Account account = as.findAccountById(1);
        System.out.println(account);
    }
    @Test
    public void testSave() {
        //1.获取容器
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        Account account = new Account();
        account.setName("test");
        account.setMoney(1234f);
        as.saveAccount(account);
        System.out.println(account);
    }
    @Test
    public void testUpdate() {
        //1.获取容器
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        Account account = as.findAccountById(1);
        account.setMoney(555f);
        as.updateAccount(account);
        System.out.println(account);
    }
    @Test
    public void testDelete() {
        //1.获取容器
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        as.deleteAccount(3);
    }
}

半注解配置案例

  1. 修改业务层
    删除setter，方法，改为注解形式
@Service("accountService")
public class AccountServiceImpl implements IAccountService {

    @Resource(name = "accountDao")
    private IAccountDao accountDao;
    .....
}
  1. 修改持久层
    删除setter方法，改为注解形式
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Resource(name = "queryRunner")
    private QueryRunner runner;
    ....
}
  1. 修改xml配置
  • 添加命名空间依赖，删除可用注解代替的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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.yll"/>

    <!--配置QueryRunner对象-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必要信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai"/>
        <property name="user" value="root"/>
        <property name="password" value="52151"/>
    </bean>
</beans>

纯注解配置案例

  1. 新建一个总配置类 config.SpringConfiguration，并用注解配置扫描的包和子配置类的字节码
	/**
	 * 此类是配置类，和bean.xml作用一样
	 */
	@Configuration
	@ComponentScan(basePackages = "com.yll")
	@Import(JdbcConfig.class)
	public class SpringConfiguration {

	}
  1. 创建子配置类 config.jdbcConfiguration，并配置properties文件源，注入jdbc相关配置和bean
/**
 * 关于数据库的配置类
 */
@Configuration
@PropertySource("classpath:jdbcConfig.properties")
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource 数据源
     * @return 对象
     */
    @Bean(name = "queryRunner")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name = "dataSource")
    @Scope("prototype")
    public DataSource createDataSource(){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(driver);
            dataSource.setJdbcUrl(url);
            dataSource.setUser(username);
            dataSource.setPassword(password);
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }
        return dataSource;
    }
}
  1. 创建jdbc配置文件
    在resources下创建配置文件jdbcConfig.properties
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=52151
  1. 修改测试类
    将获取容器的实现类修改为AnnotationConfigApplicationContext
AbstractApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
luer9
关注
专栏目录
《小马哥讲Spring核心编程思想》-第四章Spring Bean基础（1）
songhao007的博客
08-02 445
第四章 Spring Bean基础（1）定义Bean：什么是BeanDefinition？BeanDefinition元信息：除了Bean名称和类名，还有哪些Bean元信息值得关注？BeanDefinition元信息BeanDefinition 构建命名SpringBean：id和name属性命名Bean，哪个更好？SpringBean的别名：为什么命名Bean还需要别名？注册SPringBean：如何将BeanDefinition注册到IoC容器？ 定义Bean：什么是BeanDefinition？ Be
Spring Ioc(控制反转)以及DI(依赖注入)详解
Lzc的博客
06-16 1503
Struts2：web层，比较简单（难点：ValueStack值栈、拦截器） Hibernate：dao层，知识点杂（学了不用，默认设置够用了） Spring：service层，重要，（讲多少用多少） Spring课程概述： Spring day01：基础（IoC控制反转、DI依赖注入）、整合JUnit、整合Web Spring day02：AOP切面编程、JDBCTemplate Sp...
第六章-Spring IoC 注入
qq_25457701的博客
08-16 179
依赖注入的模式和类型 手动模式 - 配置或者编程的方式，提前安排注入规则 XML 资源配置元信息 Java 注解配置元信息 API 配置元信息 自动模式 - 实现方提供依赖自动关联的方式，按照內建的注入规则 Autowiring（自动绑定） 依赖注入的模式和类型 依赖注入类型 依赖注入类型 配置元数据举例 Setter 方法 ’<proeprty name="user" ref="userBean"/> 构造器 <constructor-arg name
第六章：Spring IoC 注入（1）
songhao007的博客
08-30 198
第六章：Spring IoC 注入（1）1. 依赖注入的模式和类型2. 自动绑定（Autowiring）3. 自动绑定（Autowiring）模式4. 自动绑定（Autowiring）限制和不足5. Setter 方法依赖注入6. 构造器依赖注入7. 字段注入8. 方法注入9. 回调注入10. 依赖注入类型选择 1. 依赖注入的模式和类型 手动模式 - 配置或者编程的方式，提前安排注入规则 • XML 资源配置元信息 • Java 注解配置元信息 • API 配置元信息 自动模式 - 实现方提供依赖自动关联
Spring学习笔记<五> IOC之依赖注入
AfinalStone的专栏
01-17 796
1.概述控制反转（Inversion of Control，英文缩写为IOC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup），依赖注入应用的更加广泛一些。概念没听明白？没有关系，还是通过具体的实例来认识一下依赖注入的
(一)Spring核心-IoC容器的依赖注入
qq_22866497的博客
03-28 211
依赖注入的过程是用户第一次向IoC容器索要Bean时触发的，也就是由DefaultListableBeanFactory中的getBean()这个方法触发的。具体的实现是在AbstractBeanFactory中的doGetBean()这个方法中。如果在当前的工厂中取不到Bean，就到双亲BeanFactory中取，如果当前双亲工厂取不到，就顺着双亲BeanFactory链一直向上查找，再获取当前...
Spring Boot 依赖注入 IoC 和控制反转 DI
Spring boot
09-10 671
前言 Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。 Spring Boot 被认为是 Spring MVC 的“接班人”，它可以帮我们自动配置，如果默认配置不能满足需求，我们还可以替换掉自动配置类，使用自己的配置。另外，Spring Boot 还集成了嵌入式的 Web 服务器，系统监控等很多有用的功，让我们快速构建企业及应用程序。 正文 IoC
我的Pro Spring 学习笔记 之二 控制反转(IoC)和依赖注入(DI), Spring初步
03-06
在本文中，我们将深入探讨Spring框架的核心概念——控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）。这些概念是Spring框架的基础，对于理解和掌握Spring的使用至关重要。 首先，让...
spring学习笔记 ----- (IOC/DI)
Jorgen_s的博客
04-17 230
前言：此前一直将精力放在快速输入的过程，每天学习大量的知识。虽然每天学习时间充裕，但是效率低下。究其原因，是只顾埋头输入，忘记输出。没有总结，没有自己的思考。所以，从现在开始，坚持每天输出。(Dream bigger, go higher.) 今天研究的对象是spring框架。关于spring，几乎已经统治了Javaweb开发。学习java，spring就必须掌握。 今天关注的主要的对象是其中...
第八章：Spring IoC 依赖注入（2）
songhao007的博客
10-25 150
@[TOC](第八章：Spring IoC 依赖注入(2)) 11. 基础类型注入 基础类型 • 原生类型（Primitive）：boolean、byte、char、short、int、float、long、double • 标量类型（Scalar）：Number、Character、Boolean、Enum、Locale、Charset、Currency、 Properties、UUID • 常规类型（General）：Object、String、TimeZone、Calendar、Optional 等
《小马哥讲Spring核心编程思想》-第三章Spring IoC容器概述（2）
songhao007的博客
07-26 1122
第三章Spring IoC容器概述（2）
小马哥讲Spring核心编程思想 第三周 IOC容器概述
csdn96087的博客
07-19 2999
小马哥讲Spring核心编程思想 第三周 IOC容器概述 Spring实现依赖注入的Java底层技术是Java反射技术。 ICO:Spring容器的内核，AOP、声明式事务等功能都基于此产生。 ICO不够开门见山，所以后期由Martin Fowler用DI，依赖注入的概念代替了IoC，让调用类对某一接口实现类的依赖由第三方（容器或者协作类）注入，从而移除调用类对某一接口实现类的依赖。 注入方式可以划分为三种类型：构造函数注入、属性注入和接口注入。 接口注入方式需要额外声明一个接口，增加了类的数目，并且其效果
spring实战_Spring 核心编程思想与实战
weixin_33075245的博客
01-25 192
Spring Framework 核心编程思想-源码地址专注于 Spring Framework 的核心部分，从特性简介入手，结合官方文档，在实战演练的基础上加深理解。每个章节中都会加入一些比较经典的面试题，帮助解决求职的燃眉之急。通过讲解编程模型、设计思想以及技术规范，站在哲学的高度，分析和猜想Spring 的实现可能，并结合具体源码实现，不断地进行思维和实战训练，最终达到掌握特性、理解原理，学...
《小马哥讲Spring核心编程思想》-第四章Spring Bean基础（2）
songhao007的博客
08-05 418
先写个标题
《小马哥讲Spring核心编程思想》-第二章学习笔记
songhao007的博客
07-12 4148
《小马哥讲Spring核心编程思想》-第二章学习笔记重新认识IoCIoC发展简介什么是IoC?IoC简史IoC主要实现策略IoC容器的职责依赖查找和依赖注入的区别？Spring 作为 IoC 容器有什么优势？ 重新认识IoC 本章主要讲解IoC的一些知识点 IoC发展简介 什么是IoC? IoC 是反转控制，类似于好莱坞原则，主要有依赖查找和依赖注入实现。 控制反转：获得依赖对象的过程被反转了，控制被反转之后，获得依赖对象的过程由自身管理变为了由IOC容器主动注入。 IoC简史 1983年，Richard
Spring中List、Set、Map、数组注入方式中标签的使用
HOKING的专栏
01-10 6957
在这里不多说，直接进入正题，在使用Spring时，如果对象实例含有数据或集合属性时，那我们该如何去配置Spring.xml呢？我们就需要property下的子元素list，set，map等子元素。示例为： …… or …… or …… 【转载使用，请注明出处：http://blog.csdn.net/mahoking】   操作步骤： 1、 创建Topic
Spring Ioc-依赖注入的几种方式
WEBCODE
08-31 211
一 setter方法注入 配置文件如下： &lt;bean id="helloAction" class="org.yoo.action.SpringSetterHelloAction"&gt; &lt;!-- setter injection using the nested &lt;ref/&gt; element --&gt; &lt;property name="hellose...
Java Array、List、Set互相转化
勇往直前的专栏
12-15 2403
Java Array、List、Set互相转化 1. Array、List、Set互转实例 1.1 Array、List互转 Array转List String[] s = new String[]{"A", "B", "C", "D","E"}; List&lt;String&gt; list = Arrays.asList(s); 注意这里list里面的元素直接是s里面的元素
spring学习笔记1
weixin_44737877的博客
07-31 186
控制反转(IOC)与依赖注入(DI) 原文 程序的耦合和解耦 耦合: 程序间的依赖关系.在开发中,应该做到解决编译期依赖,即编译期不依赖,运行时才依赖. 解耦的思路: 使用反射来创建对象,而避免使用new关键字,并通过读取配置文件来获取要创建的对象全限定类名. 下面以两个例子来说明如何解耦. 解耦实例1: JDBC驱动注册 JDBC操作中注册驱动时,我们不使用DriverManager的reg...
Spring框架深度解析：IoC与依赖注入（DI）
"Spring学习笔记总结，涵盖SpringMVC、IOC、AOP以及Spring与Struts2、Hibernate的集成。" Spring框架是Java开发中的一个重要组件，尤其在企业级应用开发中占据主导地位。本资源主要关注Spring的核心特性，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值