Spring是什么

Spring是一款开源的免费框架，是分层的javaSE/EE 应用full-stack轻量级开源框架，以IIoc(Inverse Of Control:反转控制)和Aop（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层SpringMVC 和持久层SpringJDBC以及业务事务管理等众多的企业级应用技术。

优势

方便解耦 ，由Spring提供的Ioc容器，将对象间的依赖关系由Spring进行控制。由Ioc容器进行注入和实例化，避免硬编码造成过分程序耦合。用户不必为属性配置文件解析，单例模式类等，关注上层代码应用以及更加容易维护代码。Aop编程支持，OOP传统难实现功能，可以通过面向切面的编程轻松实现。；声明式事务的支持 ，不需再写重复冗余的事务管理代码，通过声明方式灵活的进行事务管理，提高开放效率；方便集成各种优秀框架 ，Spring可以降低各种框架的使用难度，提供Struts2、Hibernate、Mybatis 等支持

Ioc的目的和作用

先了解什么是程序的耦合

耦合性（Coupling），也叫耦合度。耦合的强弱决定于模块间的调用和传入数据方式等关系复杂量。模块间的耦合度是指模块之间依赖关系，包括控制控制关系，调用关系，数据传递关系。关系越多，模块间的耦合向越高，其独立性就越差，我们对代码维护成本就越高。 eg：强耦代码: public class A { public void say() { System.out.println("I am A"); } } public class B { public void put(A a) { a.say(); } }

eg:弱耦合性

public interface IBase { void say(); } public class A implements IBase { @Override public void say() { System.out.println("I am A"); } } public class B implements IBase { @Override public void say() { System.out.println("I am B"); } } public class C { public void put(IBase base) { base.say(); } }

也是面向接口式编程思想，解耦

控制反转-Inversion Of Control

一般我们在获取对象是都是才自己new 对象方式 代码量上去，就不容易维护 ，以及耦合性问题。 把创建对象的权利交给了Ioc 容器，我需要对象，就找Ioc 提供。我与对象不再是直接关系，变成间接关系，消减程序代码中耦合。

Ioc容器配置

基于Xml配置

1.在类的根路径创建一个不是中文名的xml文件 2.给配置文件导入约束

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

3.让spring管理资源，在配置文件中配service和dao

<--! bean标签：用于配置让spring创建对象，并存入Ioc容器 id属性：对象的唯一标识 class属性：指定要创建对象的全限定类名，用于反射创建对象。默认情况无参构造 scope：指定对象的作用范围 singleon:同一个bean 创建同一对象 prototype:同一个bean 每次创建是不同对象 request :web项目中，Spring创建一个bean 存入request域中 session：web项目中，spring创建一个备案存入session中 init-method:指定类中初始化方法名称 destroy-method指定勒种销毁方法名称 --> <bean id="userServiceImp" class="com.woniu.service.imp.UserServiceImp" scope=“singleon”> </bean> <bean id="userController" class="com.woniu.controller.UserController" scope="prototype"> </bean>

Bean 生命周期

实例化bean对象(通过构造方法或者工厂方法)设置对象属性(setter等)（依赖注入）如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Aware接口）如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法调用Bean的初始化方法将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法 使用Bean 注意： 在bean配置上写init-method和destroy-method 是指定特定方法实现InitializingBean和DisposableBean及其方法

实例化bean 的3种方式

默认构造器实例化，它会根据默认无参构造函数来创建类对象。如果没有默认无参构造将创建失败 <bean id="hollday" class="com.woniu.entity.Hollday"></bean> 静态工厂实例化 <bean id="connection" factory-method="getConnection" class="com.woniuxy.spring.common.JDBCUtils"/> <!--某个类（JDBCUtils）的静态方法(getConnection)，返回值作为bean-->

3.工厂实例化

<bean id="druid" class="com.woniu.dao.Imp.druid"></bean> <bean id="druidFactory" factory-bean="druid" factory-method="create" ></bean>

spring 的依赖注入

依赖注入（Dependency Injection）它是spring框架核心Ioc的具体表现。业务层仍需要调用持久层的方法。通过依赖注入，两者关系。

set注入 <beans ...> <bean id="userDAO" class="com.woniuxy.spring.dao.UserDAOImpl"/> <bean id="userService" class="...UserServiceImpl"> <property name="userDAO" ref="userDAO" /> <porperty name="age" value="18"/> <property name="aList"> <list> <value></value> <bean></bean> <ref></ref> </list> </property> <property name="map"> <map> <entry key="" value=""/> .... </map> </property> </bean> <!-- 实现了FactoryBean接口，那么这个bean的类型就是car类型，getObject方法的返回值 --> <bean id="car" class="xxxx.CarFactoryBean"/> </beans> 有参构造注入 <bean id="user" class="com.service.Imp.User"> <constructor-arg index=""(name="") value/> </bean> p标签注入

基于注解的SpringIoc实现

基本注解：对类进行bean 实例化 @Controller（控制层） @Repository（持久层）@Service（业务层）@Component(不是层架构其他类)属性上注解 @Autowired @Resource

两者区别 @Resource有name和type属性；Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。 @Autowired是spring的注解，是spring2.5版本引入的，Autowired只根据type进行注入，不会去匹配name。如果涉及到type无法辨别注入对象时，那需要依赖@Qualifier或@Primary注解一起来修饰。

xml 或configuration类 xml 文件配置配置扫包 <context:component-scan back-package="">

configuration类： @Configuration @ComponentScan();

在这里插入代码片

基于Configuration类 bean实例化

@Configuration @PropertySource("jdbc.properties") public class ApplicationConfig { @Value("${jdbc.driverClass}") private String driverClassName; @Value("${jdbc.url}") private String url; @Value("${jdbc.userName}") private String userName; @Value("${jdbc.password}") private String password; @Bean public DruidDataSource druid(){ DruidDataSource source = new DruidDataSource(); System.out.printf(url); source.setDriverClassName(driverClassName); source.setUrl(url); source.setUsername(userName); source.setPassword(password); return source; } @Bean public QueryRunner queryRunner(){ return new QueryRunner(druid()); } @Bean public UserService userService(){ UserServiceImp imp = new UserServiceImp(); imp.setUserDao(userDao()); return imp; } @Bean public UserDao userDao(){ return new UserDaoImp(); } }

Aop

Aop：面向切面编程，简单来说，将程序中重复代码抽取出来，不修代码情况，采用动态代理方式，将通知织入方法，达到提高效率，减少冗余，解耦。

几个关键词

目标对象 Target 连接点 JoinPoint 切入点 Pointcut 通知 Advice 切面 Aspect 织入 Weaving

3种配置方式：

<context:component-scan base-package="com.woniu"/> <!--目标对象--> <bean id="userService" class="com.woniu.service.imp.UserServiceImp"></bean> <!--通知--> <bean id="beforeExecution" class="com.woniu.component.BeforeExecution"></bean> <bean id="methodInterceptor" class="com.woniu.component.MethodInterceptorDemo"></bean> <!--切入点--> <bean id="pointCut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"> <property name="pattern" value="com.woniu.service.imp.*Imp.*"></property> </bean> <!--切面--> <bean id="aspect" class="org.springframework.aop.support.DefaultPointcutAdvisor"> <property name="advice" ref="methodInterceptor"></property> <property name="pointcut" ref="pointCut"></property> </bean> <!--封装类--> <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean> public class XmlAudienceAround { public Object round(ProceedingJoinPoint proceedingJoinPoint){ Object[] args = proceedingJoinPoint.getArgs(); Object proceed =null; try { System.out.println("开启事务"); proceed = proceedingJoinPoint.proceed(args); System.out.println("提交事务"); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("事务回滚"); } return proceed; } } <bean id="roundAdvice" class="com.woniu.component.XmlAudienceAround"></bean> <aop:config > <aop:aspect ref="roundAdvice"> <aop:pointcut id="pointCut" expression="execution(* com.woniu.service.imp.*.*.(..)"/> <aop:around method="round" pointcut-ref="pointCut"/> </aop:aspect> </aop:config>

自定义

public class TransationAdvice { public void begin(){ System.out.println("开启事务"); } public void rollback(){ System.out.println("事务回滚"); } public void commit(){ System.out.println("事务提交"); } } <bean id="userService" class="com.woniu.service.imp.UserServiceImp"></bean> <bean id="txAdvice" class="com.woniu.component.TransationAdvice"></bean> <context:component-scan base-package="com.woniu"/> <!--切面配置--> <aop:config> <aop:aspect ref="txAdvice"> <!--切入点--> <aop:pointcut id="servicePointcut" expression="execution(* com.woniu.service.imp.*.*(..))"/> <!--通知--> <!--前置--><aop:before method="begin" pointcut-ref="servicePointcut"/> <!--后置--><aop:after-returning method="commit" pointcut-ref="servicePointcut"/> <!--异常--><aop:after-throwing method="rollback" pointcut-ref="servicePointcut"/> </aop:aspect> </aop:config>

注解方式：

@Component @Aspect public class RoundAdvice { @Pointcut("execution(* com.woniu.service.imp.*.*(..))") public void servicePointCut(){} @Around("servicePointCut()") public Object roundAdvice(ProceedingJoinPoint pjp){ Object[] args = pjp.getArgs(); Object proceed =null; try { System.out.printf("开始事务"); proceed = pjp.proceed(args); System.out.println("提交事务"); } catch (Throwable throwable) { System.out.println("事务回滚"); throwable.printStackTrace(); } return proceed; } } @Configuration @ComponentScan("com.woniu") @EnableAspectJAutoProxy public class AopRound { }