Spring Framework 笔记（一）：IoC

一：Spring中重要的概念

　　1. 容器( container ) : spring容器( ApplicationContext )的工作原则是创建容器中的组件( instance )，处理组件之间的依赖关系，并将这些组件装配到一起。

　　2. 控制反转( Inversion of Controll ) : 组件的依赖项由容器在运行时注入( injection )，而非组件自己实例化( new )，对依赖项的控制由组件转移到了容器。

二：依赖注入( dependency injection)

　　1. Bean的定义：应用程序中由Spring容器进行管理的对象称为Bean

　　2. IoC容器负责application中对象的实例化、初始化、装配和生命周期的管理。

三：IoC-demo

　　1. 新建Java项目，添加工程Jar包

　　　　1) spring核心包：org.springframework.beans、org.springframework.core、org.springframework.context

　　　　2) Java日志包：commons.logging、org.apcha.log4j 和 Log4j.properties 配置文件

　　2. demo代码

　　　　1) 领域对象

　　

 package com.znker.spring.IoC;
 
 public class Account {
 
     private long id;
     private String owerName;
     private double balance;
 
     public long getId() {
         return id;
     }
     public void setId(long id) {
         this.id = id;
     }
     public String getOwerName() {
         return owerName;
     }
     public void setOwerName(String owerName) {
         this.owerName = owerName;
     }
     public double getBalance() {
         return balance;
     }
     public void setBalance(double balance) {
         this.balance = balance;
     }
 }

　　2) AccoutDao接口与实现类

package com.znker.spring.IoC;
 
import java.util.List;
 
public interface AccountDao {
 
    public void insert(Account account);
 
    public void update(Account account);
 
    /** update方法的重载 */
    public void update(List<Account> accounts);
 
    public void delete(long accountId);
 
    public Account find(long accountId);
 
    public List<Account> find(List<Long> accountIds);
 
}

package com.znker.spring.IoC;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.springframework.stereotype.Repository;
 
@Repository("accountDao")
public class AccountDaoInMemoryImpl implements AccountDao {
 
    /** HashMap 模拟数据库 */
    private Map<Long, Account> accountsMap = new HashMap<>();
 
    {
        Account account1 = new Account();
        account1.setId(1L);
        account1.setOwerName("John");
        account1.setBalance(10.0);
 
        Account account2 = new Account();
        account2.setId(2L);
        account2.setOwerName("Mary");
        account2.setBalance(20.0);
 
        accountsMap.put(account1.getId(), account1);
        accountsMap.put(account2.getId(), account2);
    }
 
    @Override
    public void insert(Account account) {
        accountsMap.put(account.getId(), account);
    }
 
    @Override
    public void update(Account account) {
        accountsMap.put(account.getId(), account);
    }
 
    @Override
    public void update(List<Account> accounts) {
        for (Account account : accounts) {
            accountsMap.put(account.getId(), account);
        }
    }
 
    @Override
    public void delete(long accountId) {
        accountsMap.remove(accountId);
    }
 
    @Override
    public Account find(long accountId) {
        return accountsMap.get(accountId);
    }
 
    @Override
    public List<Account> find(List<Long> accountIds) {
        List<Account> accounts = new ArrayList<Account>();
        for (Long id : accountIds) {
            accounts.add(accountsMap.get(id));
        }
 
        return accounts;
    }
 
}

　　3) AccountService接口与实现类

package com.znker.spring.IoC;
 
public interface AccountService {
    /** 客户之间转账 */
    public void transferMoney(long sourceAccountId, long targetAccountId, double amount);
 
    /** 客户存款 */
    public void depositMoney(long accountId, double amount);
 
    public Account getAccount(long accountId);
}

package com.znker.spring.IoC;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service("accountService")
public class AccountServiceImpl implements AccountService {
 
    @Autowired
    private AccountDao accountDao;
 
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
 
    @Override
    public void transferMoney(long sourceAccountId, long targetAccountId, double amount) {
        Account sourceAccount = accountDao.find(sourceAccountId);
        Account targetAccount = accountDao.find(targetAccountId);
        sourceAccount.setBalance(sourceAccount.getBalance() - amount);
        targetAccount.setBalance(targetAccount.getBalance() + amount);
        /** 更新数据库记录 */
        accountDao.update(sourceAccount);
        accountDao.update(targetAccount);
    }
 
    @Override
    public void depositMoney(long accountId, double amount) {
        Account account = accountDao.find(accountId);
        account.setBalance(account.getBalance() + amount);
        accountDao.update(account);
    }
 
    @Override
    public Account getAccount(long accountId) {
        return accountDao.find(accountId);
    }
}

　　4) 为spring 容器提供Bean实例化和装配所需的配置元数据（congfiguration metadata），配置元数据可以用XML文件或Java注解提供。

　　　　XML文件版：xml-beans.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-3.2.xsd">
 
    <bean id="accountService" class="com.znker.spring.IoC.AccountServiceImpl">
        <!-- 依赖注入 accountDao -->
        <property name="accountDao" ref="accountDao" />
    </bean>
 
    <bean id="accountDao" class="com.znker.spring.IoC.AccountDaoInMemoryImpl" />
 
</beans>

　　　　Java注解版：annotation-beans.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-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd">
 
    <!-- 扫描类路径中存在的类，通过相关联的注解创建Bean并注入其依赖项中 -->
    <context:component-scan base-package="com.znker.spring.IoC" />
 
</beans>

　　5) 测试类代码

package com.znker.spring.IoC;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class TestMain {
    public static void main(String[] args) {
 
        /** 基于注解的spring容器对象实例化 */
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(BeanConfiguration.class);
        /** 基于XML文件的spring容器对象实例化 */
        ApplicationContext ctx = new ClassPathXmlApplicationContext("com/znker/spring/IoC/beans.xml");
 
        // 获取 AccountService Bean
        AccountService accountService = ctx.getBean("accountService", AccountService.class);
 
        System.out.println("Before money transfer:");
        System.out.println("Account 1 balance : " + accountService.getAccount(1).getBalance());
        System.out.println("Account 2 balance : " + accountService.getAccount(2).getBalance());
 
        // 转账
        accountService.transferMoney(1, 2, 5.0);
 
        System.out.println("After money transfer:");
        System.out.println("Account 1 balance : " + accountService.getAccount(1).getBalance());
        System.out.println("Account 2 balance : " + accountService.getAccount(2).getBalance());
 
    }
}