Spring是一款开源的免费框架，是分层的javaSE/EE 应用full-stack轻量级开源框架，以IIoc(Inverse Of Control:反转控制)和Aop（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层SpringMVC 和持久层SpringJDBC以及业务事务管理等众多的企业级应用技术。
耦合性（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();
}
}
也是面向接口式编程思想，解耦
一般我们在获取对象是都是才自己new 对象方式
代码量上去，就不容易维护 ，以及耦合性问题。
把创建对象的权利交给了Ioc 容器，我需要对象，就找Ioc 提供。我与对象不再是直接关系，变成间接关系，消减程序代码中耦合。
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 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>
依赖注入（Dependency Injection）它是spring框架核心Ioc的具体表现。业务层仍需要调用持久层的方法。通过依赖注入，两者关系。
<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>
两者区别
@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注解一起来修饰。
<context:component-scan back-package="">
configuration类：
@Configuration
@ComponentScan();
在这里插入代码片
@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：面向切面编程，简单来说，将程序中重复代码抽取出来，不修代码情况，采用动态代理方式，将通知织入方法，达到提高效率，减少冗余，解耦。
几个关键词
目标对象 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 {
}