Spring

Spring核心概念

1.Spring IoC

​ 控制翻转（Inversion of Control，IoC），也称为依赖注入（Dependency Injection，DI），是面向对象编程中的一种设计理念，用来降低程序代码之间的耦合度

/**
*用户DAO实现类。实现对User类的持久化操作
*/
public class UserMapperImpl implements UserMapper {
   
    @Override
    public void save(User user) {
   
        System.out.println("保存用户信息到数据库");
    }
}

/**
*用户业务类，实现对User功能的业务管理
*/
public class UserServiceImpl implements UserService{
   
	//实例化业务类，实现对User功能的业务管理
	private UserDao dao = new UserDaoImpl();
	public void addNewUser(User user){
   
		//调用UserDao的方法保存用户信息
		dao.save(user);
	}
}

如何使用依赖注入

public interface Ink {
   
    public String getColor(int r, int g, int b);
}

public interface Paper {
   
    public static final String newline="\r\n";

    public void putInChar(char c);

    public String getContent();

}

public class Printer {
   
    private Ink ink=null;
    private Paper paper=null;

    public  void setInk(Ink ink){
   
        this.ink=ink;
    }

    public void setPaper(Paper paper){
   
        this.paper=paper;
    }

    public void print(String str){
   
        System.out.println("使用"+ink.getColor(255,200,0)+"颜色打印：\n");
        for (int i = 0; i <str.length() ; i++) {
   
            paper.putInChar(str.charAt(i));
        }
        System.out.println(paper.getContent());
    }
}

2.Spring AOP

​ 面向切面编程(Aspect Oriented Programming, AOP)是软件编程思想发展到一定阶段的产物，是面向对象编程(Object Oriented Programming, OOP)有益补充

2.1使用Spring AOP实现日志输出

public class UserServiceImpl implements UserService {
   
    private UserDao dao= UserDaoFactory.getInstance();

    @Override
    public void addNewUser(User user) {
   
        dao.sava(user);
    }

    @Override
    public void save(User user) {
   

    }


    public void setDao(UserDao dao) {
   
        this.dao = dao;
    }

    private UserDao dao1;
}

/**
*定义包含增方法JavaBean
*/
public class UserServiceLogger {
   
    private static final Logger logger= (Logger) Logger.getLogger(String.valueOf(UserServiceLogger.class));
    public void before(JoinPoint jp){
   
        logger.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法入参:"+Arrays.toString(jp.getArgs()));
    }
    public void after(JoinPoint jp, Object result){
   
        logger.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法返回值："+result);
    }
}

Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        <bean id="dao" class="mapper.DaoImpl.UserDaoImpl"></bean>
    <bean id="service" class="service.serviceimpl.UserServiceImpl">
       <property name="dao" ref="dao"></property>
    </bean>
   <bean id="theLogger" class="service.UserServiceLogger"></bean>

    <aop:config>
         <aop:pointcut id="pointcut"expression="execution(public void addNewUser(pojo.User)pojo.User"/>
        <aop:bofore method="bofore" pointcut-ref="pointcut"></aop:bofore>
         <aop:after-returning method="after-returning" pointcut-ref="pointcut" returning="result"></aop:after-returning>
     </aop:config>
</beans>

Ioc和AOP使用扩展

3.多种方式实现依赖注入

3.1 构造注入

/**
*用户业务类，实现对User功能的业务管理
*/
public class UserServiceImpl implements UserService{
   
    //声明接口类型的引用和具体实现类解耦合
    private UserDao dao;
    
    //无参构造
    public UserServiceImpl(){
   }
    
    //用于为dao属性赋值的构造方法
    public UserServiceImpl(UserDao dao){
   
        this.dao=dao;
    }
    
    public void addNewUser(User user){
   
        //调用用户DAO的方法保存用户信息
        dao.save(user);
    }
}

Spring配置文件中将DAO对象构造注入的方式赋值给业务类对象相关属性的关键代码