Spring 3.x 企业引用开发实战（陈雄华/林开雄）

目录

　　。。。

第一章：Spring概述

　　

　　IoC：BeanFactory、Context、El（SpringEL表达式）

　　AOP：允许JVM虚拟机启动时使用代理类在运行时期修改指定类的字节码，改变一个类原本所拥有属性与行为

　　版本要求：

　　

第二章：快速入门

　　实现目标：用户登录系统

　　　　持久层：Spring JDBC

　　　　业务层：声明式事务处理

　　　　展示层：Spring MVC

　　功能描述：

　　

　　实现描述：

　　　　持久层DAO：UserDao、LoginLogDao

　　　　业务层Serviece：UserService

　　　　控制层Controller：LoginController

　　　　页面层JSP：login.jsp、main.jsp

　　UML模型：

　　

　　数据库：

　　　　创建表：　　

　　　　　　//用户　　　　　　

　　　　　　create table t_user(
　　　　　　　　user_id int auto_increment primary key,
　　　　　　　　user_name varchar(30),
　　　　　　　　credits int,　　//用户积分
　　　　　　　　password varchar(32),
　　　　　　　　last_ip varchar(23),
　　　　　　　　last_visit datetime
　　　　　　)

　　　　　　//登录日志

　　　　　　create table t_login_log(
　　　　　　　　login_log_id int auto_increment password key,
　　　　　　　　user_id int,
　　　　　　　　ip varchar(23),
　　　　　　　　login_datetime datetime
　　　　　　)

　　　　数据库提示：MySql 4.x 本身及以前版本对事务的支持并不全面，尽量使用MySql 5.x 及以上版本

　　创建工程：

　　　　导入相应依赖jar包：...

　　　　文件分层规划：（尽量层次分明）

　　　　　　操作层：src/main/java/xxx/domain　　main/java/xxx/dao　　main/java/xxx/service　　main/java/xxx/web　　main/java/xxx/...

　　　　　　配置层：main/java/xxx/resources/spirng/applicationContext.xml　　main/java/xxx/resources/log/...　　main/java/xxx/resources/...

　　　　　　测试：src/main/test/...

　　持久层Dao：

　　　　@Repository：类名注解，通过Spring定义一个持久层Bean

　　　　@Autowired：属性注解，自动注入属性对应类型的Bean（上下文容器中声明相应类型Bean）

　　　　JDBC API操作：获取连接-->创建Statement-->执行数据操作-->获取结果-->关闭Statement-->关闭结果集-->关闭连接

　　　　Spring JDBC操作：简单封装JDBC API中的操作成为org.springframework.jdbc.core.JdbcTemplate类中的模板方法，根据传入响应参数调用相应方法，执行JDBC操作

　　　　　　如查询对象：JdbcTemplate.queryForObject(String sql, Class<T> class)--->JdbcTemplate.queryForObject(sqlStr, Object[]{userName, password})

　　　　配置Spring：

　　　　　　如果JdbcTemplate引用使用注解自动注入时，由于JdbcTemplate类本身需要DataSource，需要声明定义该属性，如：

　　　　　　　　//扫描类包，将标注Spring注解的类自动转化为Bean，同时完成Bean的注入：

　　　　　　　　<context:component-scan base-package="xxx.xxx.xxx">

　　　　　　　　//使用某一开源数据源连接类声明定义dataSource数据源

　　　　　　　　<bean id="dataSource"  class="org.apache.commons.dbcp.BasicDataSource"  destroy-method="close"

　　　　　　　　　　p:driverClassName="com.mysql.jdbc.Driver"
　　　　　　　　　　p:url="jdbc:mysql://localhost:3306/test"
　　　　　　　　　　p:username="root"
　　　　　　　　　　p:password="123456" />

　　　　　　　　<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

　　　　　　　　　　p:dataSource-ref="dataSource" />

　　业务层Service：

　　　　@Service：类名注解，通过Spring注解定义一个业务Bean

　　　　@Autowired：属性注解，自动注入属性对应类型的Bean（上下文容器中声明相应类型Bean）

　　　　根据逻辑业务需要，调用持久层引用对数据库进行相应操作，而一个业务逻辑中或许有多高数据操作，需要对业务添加相应的事务控制，如配置spring事务：

　　　　　　//事务管理器　　

　　　　　　<bean id="name1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSource" />

　　　　　　//切面管理器

　　　　　　<aop:config proxy-target-class="true">

　　　　　　　　//连接点，service包下所有的方法
　　　　　　　　<aop:pointcut id="serviceMethod" expression="execution(*xxx.xxx.service..*(..))" />

　　　　　　　　//切入点
　　　　　　　　<aop:advisor pointcut-ref="serviceMethod" advice-ref="name2" />
　　　　　　</aop:config>

　　　　　　//通知

　　　　　　<tx:advice id="name2" transaction-manager="name1">
　　　　　　　　<tx:attributes>
　　　　　　　　　　<tx:method name="*" />
　　　　　　　　</tx:attributes>
　　　　　　</tx:advice>

　　单元测试：

　　　　创建单元测试类：Eclipse中-->File-->New-->Other-->Java-->JUnit--JUnit Test Case（JUnit4版本）

　　　　@RunWith(SpringJUnit4ClassRunner.class)：注解配置运行Spring测试框架

　　　　@ContextConfiguration(localtions={"/spring/applicationContext.xml"})：注解配置启动容器

　　　　@Autowired：属性注解，自动注入属性对应类型的Bean（上下文容器中声明相应类型Bean）

　　　　@Test：方法注解，标注为测试方法，可以通过Run As --> JUnit Test 运行该方法测试

　　展示层Web配置：

　　　　配置web.xml文件，使用容器启动时，自动加载spring配置文件并使用Spring MVC框架拦截请求：　　　

　　　　　　//从类路径下加载Spring配置文件，classpath关键字特指类路径下的文件
　　　　　　<context-param>
　　　　　　　　<param-name>contextConfigLocation</param-name>
　　　　　　　　<param-value>clsspath:spring/applicationContext.xml</param-value>
　　　　　　</context-param>
　　　　　　//添加spring容器启动监听器
　　　　　　<listener>
　　　　　　　　<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
　　　　　　</listener>
　　　　　　//默认请求拦截器
　　　　　　<servlet>
　　　　　　　　<servlet-name>name1</servlet-name>
　　　　　　　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
　　　　　　　　<load-on-startup>2</load-on-startup>
　　　　　　</servlet>
　　　　　　<servlet-mapping>
　　　　　　　　<servlet-name>name1</servlet-name>
　　　　　　　　<url-pattern>*.html</url-pattern>
　　　　　　</servlet-mapping>

　　　　提示：Spring 与 SpringMVC 有一个默认的契约，会默认在WEB-INF目录下寻找与name1-servlet.xml为文件并与SpringMVC配置文件的身份启动

　　控制层Controller：

　　　　@Controller：类名注解，通过Spring注解定义一个Spring MVC控制Bean

　　　　@Autowired：属性注解，自动注入属性对应类型的Bean（上下文容器中声明相应类型Bean）

　　　　@RequestMapping("name1")：类与方法注解，处理name1的请求路径，方法注解是，前面需要加上"/"

　　　　视图解析：ModelAndView(String view, String dataName, String dataVlaue) 或 String

　　控制层配置name1-servlet.xml文件：由于使用默认的视图解析，配置如下：

　　　　//扫描控制层，提供注解支持

　　　　<context-component-scan base-package="xxx.xxx.xxx">

　　　　//配置视图解析器　　

　　　　<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
　　　　　　//视图支持工具
　　　　　　p:viewClass="org.springframework.web.servlet.view.JstlView"
　　　　　　//视图路径前缀
　　　　　　p:prefix="/WEB-INF/jsp/..."
　　　　　　//视图路径后缀
　　　　　　p:suffix=".jsp" />

　　

　　配置web服务器：将项目添加进Tomcat服务器，启动服务

第三章：IoC依赖注入

　　注入类型：构造函数注入、属性注入、接口注入(不推荐，本质与属性注入无区别)

　　IoC原理：java反射机制（类加载器解析class类文件，通过代码程序方法操作类元素）

　　类加载器(ClassLoader)：描述类文件在JVM虚拟机中的对象组件，有根装载器（C++编写，java无法显示）、扩展类装载器（ExtClassLoader）、系统类装载器（AppClassLoader）

　　　　根装载器：负责加载JRE核心类库

　　　　扩展类装载器：ClassLoader的子类，负责加载JRE类库中ext目录下的jar包

　　　　系统类装载器：ClassLoader的子类，负责加载ClassPath路径下在的类包

　　　　全盘负责委托机制：默认情况只使用一个类加载器，并以根装载器-->扩展类装载器-->系统类装载器的顺序加载，如java.lang.String类永远都是根装载器负责加载

　　反射机制：Constructor、Method、Field

　　例子：

　　　　ClassLoader loader = Thread.currentThread().getContextClassLoader();
　　　　Class clazz = loader.loadClass("xxx.xxx.xxx.Test");

　　　　Constructor cons = clazz.getDeclaredConstructor((Class[])null);
　　　　Test testObject = (Test)cons.newInstance();
　　　　//无参数构造器，可以直接通过类对象获取
　　　　Test testObject = (Test)clazz.newInstance();

　　　　Method setTestParameter = clazz.getMethod("setTestParameter");
　　　　//取消java语言访问检查，私有（protected）方法也可以访问
　　　　//setTestParameter.setAccessible(ture);
　　　　setTestParameter.invoke(testObject,"parameter");

　　　　Field testField = clazz.getDeclaredField("testParameter");
　　　　//取消java语言访问检查，私有（private）属性也可以访问
　　　　//testField.setAccessible(ture);
　　　　testField.set(testObject,"parameter");

　　

　　资源装载：通过资源加载器加载配置文件路径，获取资源

　　　　资源接口：Resource

　　　　　　　

　　　　　　//系统路径资源加载
　　　　　　Resource resource = new FileSystemResource("D:/xxx/xxx/xxx/WEB-INF/classes/conf/xxx.xml");
　　　　　　//类路径资源加载
　　　　　　Resource resource = new ClassPathResource("conf/xxx.xml");

　　　　　　//Web服务器路径资源

　　　　　　......

　　　　资源地址表达式：由于不同形式的路径需要创建不同的实现类装载，为了方便添加前缀以声明路径来源，还提供了类似Ant风格表达式

　　　　　　

　　　　　　

　　　　资源加载器：

　　　　　　

　　　　　　例子：

　　　　　　　　

　　Spring容器：BeanFactory、ApplicationContext、WebApplicationContext

　　　　BeanFactory架构：

　　　　

　　　　ApplicationContext架构：

　　　　

　　　　WebApplicationContext架构：

　　　　

　　　　　　提示：WebApplicationContext容器里有ServletContext容器引用，因此，该容器适用于Web服务交互

　　　　　　

　　　　　　WebApplicationContext容器启动：需要在ServletContext容器中配置，启动容器

　　　　　　　　监听器启动模式：

　　　　　　　　　　

　　　　　　　　Servlet容器启动模式：

　　　　　　　　　　

　　　　　　　　提示：WebApplicationContext容器启动前，需要日志支持，默认加载log日志文件路径：Classpath，如：/WEB-INF/classes/log4j.properties

　　　　　　　　　　

　　Bean生命周期

　　　　BeanFactory容器加载：

　　　　　　

　　　加载分类：

　　　　　

　　　　自身初始化及销毁：init-method、destroy-method　　　　

　　　　　　配置：<bean id="xxx" class="xxx.xxx.xxx" init-method="name1" destroy-method="name2">

　　　　　　说明：name1:初始化方法名、name2:销毁方法名

　　　　Bean级生命周期接口：一般情况不需要实现，否则会形成耦合编程，与Spring解耦合编码设计不符合

　　　　全域Bean后处理器：InstantiationAwareBeanPostProcessor、BeanPostProcessor

　　　　　　InstantiationAwareBeanPostProcessor:

　　　　　　　　InstantiationAwareBeanPostProcessorAdapter类实现了InstantiationAwareBeanPostProcessor接口，因此，实现自己的InstantiationAwareBeanPostProcessor后处理程序需要如下操作：

　　　　　　　　　　MyInstantiationAwareBeanPostProcessor 继承 InstantiationAwareBeanPostProcessorAdapter类复写以下方法：　　　　　　　　　

　　　　　　　　　　　　①：public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}

　　　　　　　　　　　　②：public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {return true;}

　　　　　　　　　　　　③：public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)throws BeansException {return pvs;}

　　　　　　BeanPostProcessor：

　　　　　　　　MyBeanPostProcessor 实现 BeanPostProcessor接口，复写以下方法：

　　　　　　　　　　①：public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}

　　　　　　　　　　②：public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {return true;}

　　　　　　

　　　　　　Bean容器装载后处理器：　　　　　　　　

　　　　　　　　Resource res = new ClassPathResource("xxx.xml");
　　　　　　　　BeanFactory bf = new XmlBeanFactory(res);

　　　　　　　　((ConfigurableBeanFatory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
　　　　　　　　((ConfigurableBeanFatory)bf).addBeanPostProcessor(new MyBeanPostProcessor());

　　　　　　提示：BeanPostProcessor接口强大，为AOP功能的实现提供有力支持

　

　　ApplicationContext生命周期：

　　　

　　　　全域BeanFactory后处理器：BeanPostFactoryProcessor

　　　　　　例子：

　　　　　　

　　　　提示：ApplicationContext容器与BeanFactory容器最大的不同是ApplicationContext容器可以自动加载后处理器，而BeanFactory容器需要手动加载后处理器

　　　　加载后处理器：直接在ApplicationContext容器中声明后处理器即可，支持Bean后处理器及BeanFactory后处理器，如：　

　　　　　　<bean id="xxx" class="xxx.xxx.xxx.MyBeanPostProcessor" />
　　　　　　<bean id="xxx" class="xxx.xxx.xxx.MyBeanFactoryPostProcessor" />

　　　　　　提示：ApplicationContext容器会自动扫描该类是否实现了后处理器接口，并自动加载

第四章：配置Bean

　　Spring总视图

　　　　

　　Spring XML结构：

　　　　

　　　　提示：Bean命名可以使用id与name，建议使用唯一id，name出现重复时，会获取的后面配置的Bean对象

　　Schema约束列表：

　　　　　

　　　　

　　依赖注入：

　　　　属性注入：Bean实体类必须提供默认构造函数，并提供属性的setXxx()方法，默认情况，JVM会自动为类实现无参数构造函数。

　　　　　　提示：如果Bean复写了带参数的构造函数，则必须显示声明无参数构造函数，setXxx()与实体类属性名称可以不对应，但必须与配置文件的name值对应

　　　　　　JavaBean特殊规范：变量名的前面两个字母要么都小写，要么都大写，如：ICxxx，IPxxx，icXxx，而cDxxx，则会出现Spring容器加载配置错误

　　　　构造方法注入：

　　　　　　

　　　　　　提示：构造函数注入的前提条件是参数引用类已经初始化，如两个对象互相的构造函数的参数类型都引用对方，容器启动时，产生死锁报错，尽量使用属性注入

　　　　

　　属性值注入解析：

　　　　基本类型及其封装类、String类都可以直接使用<value>，并不需要声明，特殊字符例外：

　　　　

　　　　　　提示：可以使用<![CDATA[x&xx]]>格式，xml解析器会对该格式的内容进行转义，如：<value><![CDATA[x&xx]]></value>

　　　　类对象引用注入：<ref bean/local/parent="xxx"></ref>

　　　　　　bean：同一个容器或父容器中的bean引用，默认情况引用同一个容器中的　　local：同一个配置文件中的bean引用　　parent：父容器中的引用

　　　　null值注入：<property name="xxx"><null/></property>

　　　　

　　　　层级关联注入：<property name="name1.name2.name3" value="xxx"></property>

　　　　　　说明：在初始化该bean时，会调用getName1().getName2().setName3()方法，层级无限制

　　　　集合类型注入：

　　　　　　List：<list><value>xxx</value><value>...</value></list>

　　　　　　Set：<set><value>xxx</value><value>...</value></set>

　　　　　　Map：键与值可以接收任意类型

　　　　　　　　

　　　　　　　　Map键值对象引用：

　　　　　　　　

　　　　　　Properties：Map的特例，键与值只能是字符串类型

　　　　　　　　

　　　　简化版配置注入：

　　　　　　

　　　　　　

　　　　使用P命名空间配置：进一步简化配置

　　　　　　

　　　　自动配置：不推荐使用

　　　　　　

　　继承配置关系：<bean id="xxx" class="xxx.xxx.xxx" parent="其他bean的id值">

　　　　提示：继承其他bean的配置参数

　　依赖配置关系：<bean id="xxx" class="xxx.xxx.xxx" depends-on="其他bean的id值">

　　　　提示：如果一个bean引用到其他bean，这就需要引用bean先实例化，以上配置就是为了让依赖bean先实例化

　　整合配置关系：<bean resource="classpath:xxx.xml" />　　

　　　　提示：引入其他xml配置文件，容器只需要加载一个配置文件即可

　　延迟加载bean：<bean id="xxx" class="xxx.xxx.xxx" lazy-init="ture">

　　　　提示：该bean延迟实例化，如果有其他bean引用了改bean，则忽略延迟加载

　　自定义加载Bean：当一个类实现了FactoryBean接口后，容器获取Bean时，其实会调用FactoryBean的getObject()方法

　　　　

　　　　

　　　　　提示：如果需要获取CarFactoryBean本身实例，则容器调用需要加入"&"前缀，如：getBean("&car1");

　　Bean作用域：

　　　　

　　　　需要在Web容器（web.xml）中配置：

　　　　　　<listener>
　　　　　　　　<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
　　　　　　</listener>

　　　　不同作用域中的引用：

　　　　　　

　　　　　　提示：因为request作用域每次请求都是一个new Bean，而boss在容器中是单例存在，代理对象会有相应的请求判断

　　类注解加载：@Component("xxx")==<bean id="xxx" class="xxx.xxx.xxx.xxx">

　　　　@Repository、@Service、@Controller只是为了更好的显示区分描述类的作用，等同于@Component设置

　　　　扫描类注解自动加载：<context:component-scan base-package="xxx.xxx.xxx" />

　　　　　　

　　　　自动依赖注入：@Autowired

　　　　　　

　　　　作用域注解：@Scope("prototype")

　　　　　　提示：默认情况为@Scope("singleton")单列

　　　　

　　　　初始化与销毁注解：@PostConstruct、@PreDestroy

　　　　　　在类方法上加入以上注解类似于：@PostConstruct-->init-method，@PreDestroy-->destory-method

　　

　　Java类配置加载：@Configuration

　　　　。。。

　　

　　三大配置比较：