一：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());
}
}