spring的简介

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

起源

曾经使用过EJB开发JAVA EE应用的人，一定知道，在EJB开始的学习和应用非常的艰苦，很多东西都不能一下子就很容易的理解。EJB要严格地实现各种不同类型的接口，类似的或者重复的代码大量存在。而配置也是复杂和单调，同样使用JNDI进行对象查找的代码也是单调而枯燥。虽然有一些开发工作随着xdoclet的出现，而有所缓解，但是学习EJB的高昂代价，和极低的开发效率，极高的资源消耗，都造成了EJB的使用困难。而Spring出现的初衷就是为了解决类似的这些问题。

Spring的一个最大的目的就是使JAVA EE开发更加容易，同时他与其他框架有很好的兼容性，可以说Spring是一个提供了更完善开发环境的一个框架，可以为POJO(Plain Ordinary Java Object)对象提供企业级的服务。

Spring的初衷：

1、JAVA EE开发应该更加简单。

2、使用接口而不是使用类，是更好的编程习惯。Spring将使用接口的复杂度几乎降低到了零。

3、为JavaBean提供了一个更好的应用配置框架。

4、更多地强调面向对象的设计，而不是现行的技术如JAVA EE。

5、尽量减少不必要的异常捕捉。

6、使应用程序更加容易测试。

Spring的目标：

1、可以令人方便愉快的使用Spring。

2、应用程序代码并不依赖于Spring APIs。

3、Spring不和现有的解决方案竞争，而是致力于将它们融合在一起。

Spring的基本组成：

1、最完善的轻量级核心框架。

2、通用的事务管理抽象层。

3、JDBC抽象层。

4、集成了Toplink, Hibernate, JDO, and iBATIS SQL Maps。

5、AOP功能。

6、灵活的MVC Web应用框架。

优点

• JAVA EE应该更加容易使用。
• 面向对象的设计比任何实现技术（比如JAVA EE）都重要。
• 面向接口编程，而不是针对类编程。Spring将使用接口的复杂度降低到零。（面向接口编程有哪些复杂度？）
• 代码应该易于测试。Spring框架会帮助你，使代码的测试更加简单。
• JavaBean提供了应用程序配置的最好方法。
• 在Java中，已检查异常（Checked exception）被过度使用。框架不应该迫使你捕获不能恢复的异常。

接下来让我们进入spring的世界把（这里我们使用的是maven环境）

首先导入spring的依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.4.RELEASE</version>
</dependency>

1.首先讲IOC bean的加载   

1.1懒加载（延时加载）beanFactory（单例模式）

//BeanFactory延迟加载 单例（方法过时了不推荐使用）

  @Testpublic  void  createbean(){//加载spring.xml配置文件BeanFactory beanFactory=new XmlBeanFactory(new ClassPathResource("spring.xml"));//获取users  bean对象user user=(user) beanFactory.getBean("users");//输出System.out.println(user);System.out.println(user);}

1.2及时加载ClassPathXmlApplicationContext 

//ApplicationContext及时加载（常用）（默认是单例模式，需要在bean中添加scope来改变他是否是单例模式 scope=prototype每次都创建一个新的对象）

 public void demo() throws Exception {
//加载spring.xml文件ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
//得到bean对象user user=(user)applicationContext.getBean("users");
//输出System.out.println(user);}

2bean的常用属性

id ：用于getbean（）方法  id不能为特殊字符 ；

class：创建对象所在类的路径；

name：功能和属性id差不多，可以是特殊字符；

scope：作用域

singleton：默认 在每一个springioc容器中定义对应一个对象实例；

prototype：一个bean对应多个对象实例；

request：在一次HTTP请求中，一个bean对应一个对象实例，每次都会有各自的bean实例，他们根据某个bean定义创建而成，只在web的spring ApplicationContext下有效；

session：在一个HTTP sesion中，一个bean定义一个实例，只在web的spring ApplicationContext下有效；

global-session：global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

spring.xml

<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-4.3.xsd>
<!--创建一个uers的bean--><bean id="users"   class="com.zx.pojo.user" scope="prototype"></bean</beans>

3注入

1.value直接赋值

  <!--<bean id="users"   class="pojo.user" scope="prototype">--><!--<property name="uid" value="1"></property>--><!--<property name="uname" value="2"></property>--><!--<property name="upwd" value="3"></property>--><!--</bean>-->

2.集合注入

list

<!--<bean id="lists" class="pojo.lists">--><!--<property name="lists">--><!--<list>--><!--<ref bean="users"></ref>--><!--<ref bean="users2"></ref>--><!--</list>--><!--</property>--><!--</bean>-->

map

 <!--<bean id="map" class="pojo.map" scope="prototype">--><!--<property name="usermap" >--><!--<map>--><!--<entry key="1" value-ref="users"></entry>--><!--<entry key="2" value-ref="users2"></entry>--><!--</map>--><!--</property>--><!--</bean>-->

构造方法注入：（constructor-arg）

 <bean id="users" class="pojo.user"><constructor-arg index="0" value="123456"></constructor-arg><constructor-arg index="1" value="密码"></constructor-arg><constructor-arg index="2" value="aaaaa"></constructor-arg></bean>

初始化方法inti-method 会初始化bean的时候使用。

<bean id="users"   class="pojo.user" scope="prototype" init-method="initusers"><property name="uid" value="1"></property><property name="uname" value="2"></property><property name="upwd" value="3"></property><bean/>

public void inituser(){
System.out.println("这是初始化的方法");
}

2.spring Aop

spring代理

1.接口

public interface Iperson {public void slip();public  void personadd();
}

 2.实现类

    @Overridepublic void slip() {System.out.println("睡觉！");}

3.spring.xml

<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-4.3.xsd">
<!--配置目标--><bean id="xm" class="Xiaoming"></bean><!--配置混合代理--><bean id="myproxy"  class="org.springframework.aop.framework.ProxyFactoryBean"><!--引用目标对象--><property name="target" ref="xm"></property><property name="proxyInterfaces"><list><value>Iperson</value></list></property></bean></beans>

4.测试

 @Testpublic void Springproxy() {
//加载spring.xmlClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
//获取beanIperson ip = (Iperson) applicationContext.getBean("myproxy");
//实现方法ip.slip();}

2通知

前置通知：在方法前调用（可以存放session）实现MethodBeforeAdvice接口

public class mybefore implements MethodBeforeAdvice{@Overridepublic void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println("使用了前置通知");}
}

后置通知：在方法后调用（可以做权限的判断）实现AfterReturningAdvice接口

public class myafor  implements AfterReturningAdvice{@Overridepublic void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {System.out.println("我是后置通知");}
}

环绕通知：在方法执行前后执行（日志）实现MethodInterceptor接口

public class Hrtongzhi implements MethodInterceptor{@Overridepublic Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("环绕通知");return methodInvocation.proceed();}
}

配置spring.xml

<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-4.3.xsd">
<!--配置目标-->
<!--配置前置通知--><bean id="mybefore" class="mybefore"></bean>
<!--配置通知的过滤--><bean id="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice" ref="mybefore"> </property><property name="pattern" value=".*add.*"></property></bean>
<!--配置后置通知-><bean id="afore" class="myafor"></bean>
<!--配置环绕通知--><bean id="hr" class="Hrtongzhi"></bean><!--配置混合代理--><bean id="myproxy"  class="org.springframework.aop.framework.ProxyFactoryBean"><!--引用目标对象--><property name="target" ref="xm"></property>
<!--引用接口--><property name="proxyInterfaces"><list><value>Iperson</value></list></property><property name="interceptorNames" >
<!--应用通知--><list>
<!--引用过滤前置通知--><idref bean="advisor"></idref>
<!--引用前置通知--><!--<idref bean="mybefore"></idref>-->
<!--引用后置通知--><!--<idref bean="afore"></idref>-->
<!--引用环绕通知--><!--<idref bean="hr"></idref>--></list></property>
</beans>

3测试

 @Testpublic void Springproxy() {
//加载spring.xmlClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
//获取beanIperson ip = (Iperson) applicationContext.getBean("myproxy");
//实现方法ip.slip();
//实现方法过滤通知ip.presonadd();}

总结：spring我只了解了个大概还有很多东西没接触，我以后会慢慢学习的，请大佬们多多指点。