Spring技术

Spring是一种优秀的轻量级企业应用解决方案，它倡导一切从实际出发，核心技术IOC（控制反转）和AOP（面向切面编程）技术。它为java带来了一种全新的编程思想，其目的是解决企业应用开发的复杂性。

IOC概述

IOC：控制反转，控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护。

DI（依赖注入）：是一种实现方式。

目的：创建对象并且组装对象之间的关系。

bean容器的初始化

1）bean容器中重要的两个包：org.springframework.beans和org.springframework.context.

2)BeanFactory提供配置结构和基本功能，加载并初始化Bean。

3）ApplicationContext保存了Bean对象并在Spring中被广泛使用。

4）Beans加载方式：本地加载、Classpath、Web应用中依赖servlrt或Listener。

本地文件加载

FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("F:/xxx.xml");

Classpath(相对路径文件加载)

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext ("classpath:appliication.xml");

Web应用中加载

<lisrener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listen-class>
</listener>
<servlet>
       <servlet-name>context</servlet-name>
       <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
</servlet>

Spring注入

1）Spring注入是指在启动Spring容器加载bean配置的时候，完成对变量的赋值行为。

      Spring在加载的时候会扫描xml文件的bean，为bean对象实例化。

2）常用的两种注入方式：设值注入、构造注入

User类

public interface AbstractUser {

	public void save(String str);
}

public class User implements AbstractUser{

	@Override
	public void save(String str) {
		System.out.println("保存用户"+str);
	}

}

servlet类

public interface AbstractServlet {

	public void done();
}

public class Servlet implements AbstractServlet {

	AbstractUser user;
	
	//构造器注入
	public Servlet(AbstractUser user){
		this.user = user;
	}
	//setter注入
	public void setUser(AbstractUser user) {
		this.user = user;
	}

	@Override
	public void done() {
		user.save("hello");
		System.out.println("操作成功");
	}

}

Main类

public class Main {

	public static void main(String[] args) {
		
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext ("classpath:appliction.xml");
		Servlet servlet = (Servlet) context.getBean("servlet");
		servlet.done();
	}
}

application.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.xsd" >
        
        <!-- setter方式注入 -->
        <!--  <bean id="servlet" class="servlet.Servlet" scope="singleton">   <!-- scope设置单例模式 -->
         	<property name="user" ref="Myuser"></property> 
         </bean> --> 

		<!-- 构造器方式注入 -->
		<bean id="servlet" class="servlet.Servlet">
        	<constructor-arg name="user" ref="Myuser"></constructor-arg>
        </bean>
        
        <bean id="Myuser" class="user.User"></bean>
	
 </beans>

Bean的作用域

1）singleton：单例，指一个Bean容器中只存在一份。

2）prototype：每次使用都会创建新的实例，destroy方式不生效。

3）request：每次http请求创建一个实例仅在当前request内有效。

4）session：同上。每次http请求创建，当前session内有效。

5）global session：基于protlet的web中有效，如果在web中，同session。

Spring注解实现自动检测与注册Bean

1）@Component是一个通用注解，可用于任何Bean。

2）@Repository，@Service，@Controller是更有针对性的注解。

      @Repository通常注解DAO类，即持久层。

      @Service通常用于注解Service层，即服务层。

      @Controller通常注解Controller层，即控制层。

3）使用注解配置

<!--<context:annotation-config/>-->    <!-- 使用注解 -->
<context:component-scan base-package="org.example"> <!-- 指定自动扫描注册org.example包下的类 -->

4）自定义扫描过滤器

<bean>
       <context:component-scan base-package="org.example">
              <context:include-filter type="regex" expression=".*Stub.*Repository"/> <!-- 扫描 -->
              <context:exclude-filter type="annotation" expression="org.springframework.Repository">  <!-- 不扫描 -->
       </context:component-scan>
</bean>

5）Autowired注解

      @Autowired可以运用于常量、setter方法、构造器上面。

6）基于java的容器注解

      下面两段代码等同

@Configuration
public class a（）｛
    
     @bean
     public Student myStu（）{
             return new Student();
     }
｝

                ||

<beans>
     <bean id="myStu" class="XXX.XXX.Student"></bean>
</beans>

Spring的AOP

1）AOP概念

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

主要的功能有：日志记录，性能统计，安全控制，事务处理，异常处理等等。

2）基本的AOP

Spring所有的切面和通知器都必须放在一个<aop:config>内（可以配置多个<aop:config>元素），每一个<aop:config>可以包含pointcut,advisor和aspect元素（注意的是：它们必须按照这个顺序声明）

3）配置自己的AOP

<bean id="aopcut" class="com.cqut.AopDemo"></bean>
<bean id="allClass" class="com.cqut.AllClass"></bean>
<aop:config>
  <aop:aspect id="myID" ref="aopcut">
	<aop:pointcut expression="execution{* com.cqut.AllClass.*(...)}" id="piontcut"/> <!-- 选择com.cqut.AllClass的所有方法 -->
	<aop:before method="myBefore" pointcut-ref="piontcut"/>  <!-- 执行com.cqut.AllClass方法之前先执行myBefore方法 -->
  </aop:aspect>
</aop:config>

一般类

public class AllClass {

	public void myMethod(){
		System.out.println("执行方法");
	}
}

切片类

public class AopDemo {

	public void myBefore(){
		System.out.println("我的之前");
	}
	public void myReturn(){
		System.out.println("我的返回");
	}
	public void myThrow(){
		System.out.println("我的抛出");
	}
	public void myAfter(){
		System.out.println("我的之后");
	}
}