OGNL表达式语句：
- OGNL(Object DGraph Navigation Language):是一种强大的表达式语言,能够自动导航对象的结构并访问和设置对象数据
- OGNL上下文相当于一个Map容器,在Map容器中可以保存任何类型的数据(对象、数组等)
基本格式,如：
JavaBean对象User{id:int; name:String}访问属性的方式为：
#user.name
ONGL表达式语言的特点：
- 支持对象方法的调用
- 支持井台方法的调用
- 支持变量的赋值
- 可以操作 集合数据
Struts2中的OGNL：
- 在Struts2中,OGNL上下文作用于Struts2中的ActionContext对象
ActionContext中的对象：
- 值栈(根)、application、session、request、parameters、attr
获取application中的对象：
#application.name或#application.['name']获取request中的对象：
#request.name或#request.['name']获取session中的对象：
#session.name或#session.['name']获取parameters中的对象：
#parameters.name或#parameters.['name']获取attr中的对象：
#attr.name或#attr.['name']
在JSP页面中获取对象的属性：
<s:property value="user.id" /> 或 <s:property value="user[id]" />注意：Struts2的JSP页面需要导入标签库：
<%@taglib prefix="s" uri="/struts-tags"%>
静态属性的调用方法如下：
//通过@符号来标注 @com.michale.djh.Bean@NAME注意：默认情况下,struts2不允许调用静态方法,需要在struts.xml文件中手动开启
<constant name="struts.ognl.allowStaticMethodAccess" value="true" />
访问集合：
- List集合：(有序集合),可以使用下标的方式访问,如：list[0]
- Set集合：(无序集合),不能通过下标的形式访问
Map集合：键值对形式,通过key访问value:
map.key 或 map.['key']获取所有的Key和value:
map.keys //获取所有的Key map.values //获取所有的value
集合的操作：
collection.isEmpty//判断集合元素是否为空 colloection.size()//获取集合的长度投影与选择：
投影：对集合中列的操作,指将集合中的某一列数据都抽取出来形成一个集合,如：
#list.{name} //获取一个包含多个学生对象集合的所有学生姓名选择：对集合中行的操作,指通过一定的条件获取集合中满足这一条件的的数据,所获取的行就是对集合中数据的选择操作,如：
#list.{?#this.age>10}//获取所有年龄大于10的所有学生,"?"表示满足这一条件的所有对象
- OGNL表达式中的操作符：
- ?：获取满足指定条件的所有元素
- ^：获取满足指定条件的所有元素中的第一个元素
- $：获取满足指定条件的所有元素中的最后一个元素
Struts2的标签库
数据标签：
- property：用于获取数据值,并将数据值直接输出到页面中，其属性如下：
- default：可选
- escape：可选
- escapeJavaScript：可选
- value：可选
set：用于定义一个变量,可以为所定义的变量赋值及设置变量的作用域(application、request、session),set标签属性：
- scope(String)：可选,设置变量的作用域，其默认值是action
- value(String)：可选,设置变量的值
- var(String)：可选,定义变量的名称
set标签用法：
<s:set var="username" value="test set tag" scope="request"></s:set> <s:set default="no data!" value="#request.username"/>
- a：用于构建超链接,常用属性：
- action(String)：将超链接的地址指向action
- href(String)：超链接地址
- id(String)：设置HTML中的属性名称
- method(String)：如果超链接的地址指向action,method同时可以为action声明所调用的方法
- namespace(String)：可以为action声明命名空间
- param：用于对参数赋值,属性如下：
- name(String)：设置参数名称
- value(Object)：设置参数值
- action：用于执行 一个Action请求,可以将Action的返回结果输出到当前页面中,也可以不输出,其属性如下：
- executeResult(String)：是否使Action返回到执行结果,默认值为false
- flush(Boolean)：输出结果是否刷新,默认值为true
- ignoreContextParams(Boolean)：是否将页面请求参数传入被调用的Action,默认值为false
- name(String)：Action对象所映射的名称,也即是struts.xml中配置的名称
- namespace(String)：指定名称空间的名称
- var(String)：引用此action的名称
push：用于将对象或值压入到值栈中并放置到顶部,简化操作,用法如下：
<s:push value="#request.student"></s:push>- date：用于格式化日期时间,可以对日期时间值进行指定的格式化样式格式化,包含的属性如下：
- format(String)：设置格式化日期的样式
- name(String)：日期值
- var(String)：格式化时间的名称变量,通过该变量可以对其进行引用
include：类似于JSP的include标签,添加了可以在目标页面中通过param标签传递请求参数的功能,用法如下：
<%@include file="/pages/common/admin.jsp"%>- url
- property：用于获取数据值,并将数据值直接输出到页面中，其属性如下：
控制标签：
if:
- :可以单独使用
- :配合使用
- :配合使用
使用方式：
<s:if test="表达式(布尔值)"> //test属性用于设置标签的判断条件,其值为布尔类型的条件表达式,如： expression1 <s:if> <s:elseif test="expr(Boolean)"> expression2 </s:elseif> ... <s:else> expression3 </s:else>
- iterator：可以遍历数组和集合类中的所有或部分数据(可以指定迭代数据的起始位置、步长以及终止位置来迭代集合或数组中的部分数据),其属性如下：
- begin(Integer)：指定迭代数组或集合的起始位置,默认值为0
- end(Integer)：指定迭代数组或集合的结束位置,默认值为集合或数组的长度
- status(String)：迭代过程中的状态
- step(Integer)：迭代的步长,默认值为1
- value(String)：指定迭代的集合或数组对象
- var(String)：设置迭代元素的变量,若指定此属性,那么迭代的变量将压入到值栈中
数据的验证机制：
- 手动验证的实现： 在继承ActionSupport类的情况下,重写validate()方法,在该方法中进行验证
- 验证文件的命名规则： 验证文件的名称必须是以下两种：(ActionName是Action对象的名称,AliasName为Action配置中的名称,也即是struts.xml配置文件中Action元素对应name属性的名称)
- ActionName-validation.xml: 数据的验证会作用于整个Action对象中,并验证Action对象的请求业务处理方法，适用于验证处理的规则都相同的形式
- ActionName-AliasName-validation.xml： 更加灵活。
验证文件的编写风格：
字段验证器编写格式： 如：验证用户名与密码(注意xml文件需要指定编码格式),其中name为需要检验的字段
<validators> <field name="username"> <field-validator type="requiresstring"> <message>Please Input user name</message> </field-validator> </field> <field name="password"> <field-validator type="requiresstring"> <message>Please Input password</message> </field-validator> </field> </validators>非字段验证器编写格式： 如：用户名与密码验证
<validators> <validator type="requiredstring"> <param name="fieldName">password<param> <param name="fieldName">username<param> <message>Please Input text</message> </validator> </validators>- 使用param标签传递字段参数,其参数的名称为fieldName,参数的内容为字段的名称
- 对于字段验证时,通常使用字段验证器编写格式
案例：
index.jsp:
<body> <h2>User Register</h2> <s:form action="userAction" method="post"> <s:textfield name="name" label="user_name" required="true" requiredPosition="left"></s:textfield> <!-- label标签用于定义页面显示的字段名 --> <s:password name="password" label="pass_word" required="true" requiredPosition="left"></s:password> <s:radio name="sex" list="#{1:'male', 0:'female' }" label="sex" required="true" requiredPosition="left"></s:radio> <s:select list="{'Please select province', 'JiLin', 'GuangDong', 'ShanDong', 'JiangXi'}" name="province" label="Province"></s:select> <s:checkboxlist list="{'football','basketball', 'table tennis'}" name="hobby" label="interest"></s:checkboxlist> <s:textarea name="description" cols="30" rows="5" label="desc"></s:textarea> <s:submit value="Register"></s:submit> <s:set value="Reset"></s:set> </s:form> </body>struts.xml:
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="default" namespace="/" extends="struts-default"> <action name="userAction" class="com.michael.djh.demo1.UserAction"> <result>success.jsp</result> </action> </package> </struts>UserAction.java:
public class UserAction extends ActionSupport { private static final long serialVersionUID = 1L; private String name; private String password; private String description; private int sex=0; private String province; private String[] hobby; @Override public String execute() throws Exception { // TODO Auto-generated method stub return SUCCESS; } //Getter and Setter method ...... }
- 默认情况下,Struts2的验证框架验证失败后会返回input对应的页面
struts2的配置文件：
struts.xml:
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <constant name="struts.devMode" value="true" /> <package name="default" namespace="/" extends="struts-default"> <action name="userAction" class="com.michael.djh.demo1.UserAction"> <result>success.jsp</result> </action> <action name="login" class="com.michael.djh.demo1.LoginAction"> <result name="input">login.jsp</result> <result>success.jsp</result> </action> </package> </struts>web.xml:
<?xml version="1.0" encoding="UTF-8"?> <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Struts 2 Rest Example</display-name> <welcome-file-list> <welcome-file>login.jsp</welcome-file> </welcome-file-list> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app>
Hibernate：
- Hibernate通过持久化类(.java)、映射文件(.hbm.xml)与配置文件(*.cfg.xml)操作关系型数据库
- Hibernate三大类：
- 配置类(Configuration)： 负责管理Hibernate的配置信息以及启动Hibernate,包含数据库URL、数据库用户名、数据库用户密码、数据库驱动类及数据库适配器(dialect)
- 会话工厂类(SessionFactory)： 用于声称Session的工厂,保存了当前数据库中所有的映射关系,是[线程安全]的,为一个重量级对象,初始化创建过程会耗费大量的系统资源
- 会话类(Session)： 数据库持久化操作的核心,负责Hibernate所有的持久化操作,可以实现数据库的CRUD操作,但会话类并不是线程安全的,应避免多个线程共享一个Session
Hibernate通过读取默认的XML配置文件hibernate.cfg.xml加载数据库的配置信息,该配置文件被默认放于项目的classpath根目录下,如：
//连接应用的MySQL数据库 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.username">root</property> <property name="connection.password">java</property> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> //Hibernate方言 <property name="show_sql">true</property> <mapping resource="com/michael/djh/employee/Employee.hbm.xml" /> //打印SQL语句 <mapping resource="com/michael/djh/user/User.hbm.xml" /> //映射文件 </session-factory> </hibernate-configuration>- property元素的常用配置属性：
- connection.driver_class：连接数据库的驱动
- connection.url：连接数据库的URL地址
- connection.username：连接数据库用户名
- connection.password：连接数据库密码
- dialect：设置连接数据库使用的方言
- show_sql：是否在控制台打印SQL语句
- format_sql：是否格式化SQL语句
- hbm2ddl.auto：是否自动生成数据库表
- property元素的常用配置属性：
- Hibernate中的持久化类编成规则：
- 实现一个默认的构造函数: 所有的持久化类中都必须含有一个默认的无参数构造方法，通过Constructor.newInstance()实例化持久类
- 提供一个标识属性(option): 一般用于映射数据库表中的主键字段
- 使用非final类(option): 使用final类,Hibernate就不能使用代理来延迟关联加载,会影响开发人员进行性能优化的选择
- 为属性声明访问器(option): 持久化类的属性不能声明为public的,最好以private的set()和get()方法对属性进行持久化
Hibernate映射：
映射文件的命名规则为：*.hbm.xml,如(User对象配置)：
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.michael.djh.User" table="tb_user"> <id name="id" column="id" type="int">//持久化类的唯一标识 <generator class="native" /> </id> <property name="name" type="string" not-null="true" length="50"> <column name="name" /> </property> <property name="password" type="string" not-null="true" length="50"> <column name="password" /> </property> </class> </hibernate-mapping>- 元素包含一些可选的属性：
- schema：指该文件映射表所在数据库的schema名称
- package：指定一个包前缀
- 元素用于指定持久化类和映射的数据库名,name属性需要指定持久化类的全限定的类名,table属性就是持久化类所映射的数据库表名
- 元素用于持久化类的其他属性和数据表中非主键字段的映射,其属性有以下几个：
- name：持久化类属性的名称,以小写字母开头
- column：数据库字段名
- type：数据库的字段类型
- length：数据库字段定义的长度
- not-null：该数据库字段是否可以为空,属性值为布尔变量
- unique：该数据库字段是否唯一
- lazy：是否延迟抓取
Hibernate数据持久化：
- Hibernate的实例三种状态：
- 瞬时状态(Transient)
- 持久化状态(Persistent)
- 脱管状态(Detached)
Hibernate工具类,避免Session的多线程共享数据问题, SessionFactory的获取：
Configuration configuration = new Configuration.configure(); SessionFactory factory = configuration.buildSessionFactory();- Configuration对象会自动加载Hibernate的基本配置信息,如果没有在configure()方法中指定加载配置XML文档的路径信息,Configuration对象会默认加载项目classpath下的hibernate.cfg.xml文件
HibernateUtil.java:(用于初始化Hibernate)
public class HibernateUtil{ private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); private static SessionFactory sessionFactory = null; static{ try{ Configuration configuration = new Configuration.configure(); sessionFactory = configuration.buildSessionFactory(); }cathc(Exception e){ e.printStackTrace(); } } //get Session public static Session getSession() throws HibernateException(){ Session session = (Session)threadLocal.get(); if(session == null || !session.isOpen()){ if(sessionFactory == null){ rebuildSessionFactory(); } session = (sessionFactory != null) ? sessionFactory.openSession : null; threadLocal.set(session); } return session; } public static void rebuildSessionFactory(){ try{ Configuration configuration = new Configuration.configure(); sessionFactory = configuration.buildSessionFactory(); }cathc(Exception e){ e.printStackTrace(); } } //get SessionFactory public static SessionFactory getSessionFactory(){ return sessionFactory; } //close Session public static void closeSession() throws HibernateException{ Session session = (Session)threadLocal.get(); threadLocal.set(null); if(session != null){ session.close(); } } }
数据保存：
数据的持久化过程：
application->Configuration->SessionFactory->Session->数据操作->正常commit,失败rollback->close()开启事务：
session.beginTransaction();执行数据库添加操作：
session.save(user);事务提交：
session.getTransaction().commit();事务回滚：
session.getTransaction().rollback();- 注意：最后需要关闭session.
查询数据：Session对象提供了两种对象装载的方法，即get()与load()方法
- get()方法：装载对象后会立刻访问数据库，适用于不确定数据库中是否有匹配的记录存在时用
- load()方法：返回对象的代理,只有在返回对象被调用时,Hibernate才会发出SQL语句去查询对象
如：
User user = (User)session.get(User.class, new Integer("1")); String name = user.getName(); String sex = user.getSex(); ...
- 删除数据：delete()方法, 只有对象在持久化状态时才能执行delete()方法
- Hibernate的实例三种状态：
延迟加载： load方法或者设置property元素的lazy属性,如：
<hibernate-mapping> <class name="com.michael.djh.User" table="tb_user"> <id name="id" column="id" type="int"> <generator class="native" /> </id> <property name="name" type="string" length="15" lazy="true"> <column name="name" /> </property> </class> </hibernate-mapping>- 通过上述方式的设置,用户的姓名属性就被设置成了延迟加载
Hibernate缓存：
- 缓存分类：
- 一级缓存(Session level)：也称为内部缓存,生命周期与Session相同
- 二级缓存(SessionFactory level)：用于数据更新频率低,系统频繁使用的非关键数据,以防止用户频繁访问数据库,过度消耗资源
- 在Hibernate中不同的Session之间是不能共享一级缓存的,也即是一个Session不能访问其他Session在一级缓存中的对象缓存实例
利用EHCache作为Hibernate的二级缓存的配置，如：(查询产品信息)
hibernate.cfg.xml:
<hibernate-configuration> <session-factory> ... <property name="hibernate.cache.use_second_level_cache">true</property>//开启二级缓存 <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property> </session-factory> </hibernate-configuration>在持久化类的映射中需要指定缓存的同步策略,关键代码如下：
<hibernate-mapping> <class name="com.michael.djh.Product" table="tb_product"> <cache usage="read-only" /> //指定的缓存的同步策略 ... </class> </hibernate-mapping>缓存的配置文件放在classpath目录下ehcache.xml(在Hibernate的zip包下的etc目录中可查看到),代码如下：
<ehcache> <diskStore path="java.io.tmpdir" /> <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" OverflowToDisk="true" /> </ehcache>
- 缓存分类：
实体关联关系映射：
多对一单向关联：
product与factory表：
tb_product{id, name, price, factoryid} tb_factory{factoryid, name}在产品对象的映射文件中建立多对一的关联,代码如下：(Product类引用Factory类)
<hibernate-mapping> <class name="com.michael.djh.Product" table="tb_product"> <id name="id" column="id" type="int"> //id 值 <generator class="native" /> </id> <property name="name" type="string" length="45"> //product name <column name="name" /> </property> <property name="price" type="double"> //product price <column name="price" /> </property> <many-to-one name="factory" class="com.michael.djh.Factory"> //多对一关联映射 <column name="factoryid" /> //映射字段 </many-to-one> </class> </hibernate-mapping>- 单向多对一关联时,只能通过主控方对被动方进行级联更新
多对一双向关联：
Product与Factory类：
Product{int:id, String:name, double:price, Factory:factory} Factory{int:factoryid, String:factoryName, Set:products}映射代码：
<hibernate-mapping> <class name="com.michael.djh.Factory" table="tb_factory"> <id name="factoryid" column="factoryid" type="int"> //id 值 <generator class="native" /> </id> <property name="factoryName" type="string" length="45"> //product name <column name="factoryname" /> </property> <property name="price" type="double"> //product price <column name="price" /> </property> <set name="products" inverse="true"> //定义一多映射 <key column="factoryid" /> <one-to-many class="com.michael.djh.Product" /> </set> </class> </hibernate-mapping>
级联操作：
- 指的是当主控方执行save、update、delete操作时，关联对象(被控方)是否进行同步操作,可以通过cascade属性来设置,其属性值如下：
- all：所有情况下均采用级联操作
- none：默认的参数,所有情况下均不采用级联操作
- save-update：在执行save-update方法时执行级联操作
- delete：在执行delete方法时执行级联操作
映射文件的配置,如：
<hibernate-mapping> <class name="com.michael.djh.User" table="tb_user"> ... <one-to-one name="com.michael.djh.IDCrad" cascade="all"> </class> </hibernate-mapping>
- 指的是当主控方执行save、update、delete操作时，关联对象(被控方)是否进行同步操作,可以通过cascade属性来设置,其属性值如下：
HQL(Hibernate Query Language)：Hibernate查询语言
- 完全面向对象的查询语言,提供了更加面向对象的封装,返回的是匹配的单个实体对象或多个实体对象的集合
- HQL语句区分大小写(由于查询的是对象,对象是Java类,而Java大小写敏感)
HQL的基本语法：
select "对象.属性名" from "对象" where "过滤条件" group by "对象.属性名" having "分组条件" order by "对象.属性名"如：
select * from Employee emp where emp.flag='1' 等价于 from Employee emp where emp.flag='1'
通过from子句查询指定字段数据，如：
select Person(id, name) from Person per如：查询Employee对象的所有信息
List employees = new ArrayList(); Session session = null; session = HibernateUtil.getSession(); String hql = "from Employee employee"; Query query = session.createQuery(hql); employees = query.list(); HibernateUtil.closeSession();HQL参数邦定机制：
- 参数邦定机制可以使查询语句和参数具体值相互独立，不但可以提高程序的开发效率，还可以有效地防止SQL的注入攻击
HQL提供动态赋值的两种实现方式：
利用顺序占位符”?”替代具体参数,如：(类似于JDBC中的PreparedStatement对象的操作方式)
//查询性别为"male"的员工信息 session = HibernateUtil.getSession(); String hql = "from Employee employee where employee.sex=?"; Query query = session.createQuery(hql); query.setParameter(0, "male"); employees = query.list();利用引用占位符”:parameter”替代具体参数,引用占位符是”:”与自定义参数名的组合,如：
session = HibernateUtil.getSession(); String hql = "from Employee employee where employee.sex=:sex"; Query query = session.createQuery(hql); query.setParameter("sex", "male"); employees = query.list();
排序查询：使用的是对象的属性,如：
//以年龄从小到大排序 from Employee employee order by employee.age desc聚合函数,类似于SQL,如：
select avg(employee.age) from Employee employee
Spring框架：
- 由七大核心模块组成:
- Core：支持工具类,bean容器,实现了IoC模式,包含重要的BeanFactory类
- Context：继承BeanFactory类,Context验证、JNDI、EJB、E-mail等
- AOP：元数据及动态代理实现
- DAO：事务基础设施、JDBC、DAO,简化数据库厂商的异常错误
- ORM：支持Hibernate、iBatis与JDO
- WEB：建立在Context之上,提供了Servlet监听器的Context和Web应用的上下文
- MVC：Web MVC框架、Web视图,实现控制逻辑和业务逻辑清晰的分离
Spring内置了日志组建log4j.jar,所以在使用Spring之前需要对log4j进行简单的配置,即在src根目录下创建log4j.properties 属性文件,代码如下：
#输出级别,输出错误信息,输出源为标准出源stdout log4j.rootLogger=WARN.stdout #将stdout输出到控制台 log4j.appender.stdout=org.apache.log4j.ConsoleAppender #日志输出的布局类 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout #指定日志输出内容的格式 log4j.appender.stdout.layout.ConversionPattern=%d %p [%c]-%m %n使用BeanFactory管理bean
BeanFactory通过从XML配置文件或属性文件中读取JavaBean的定义,来实现JavaBean的创建、配置和管理,其中XmlBeanFactory可以通过流行的XML文件格式读取配置信息来装载JavaBean,如：
Resource resource = new ClassResource("applicationContext.xml"); BeanFactory factory = new XmlBeanFactory(resource); Test test = (Test)factory.getBean("test");applicationContext.xml:
<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="test" class="com.michael.test.Test" /> </beans>Spring中bean的生命周期：
实例化JavaBean、初始化JavaBean、使用JavaBean、销毁JavaBean
依赖注入：IoC(Inversion of Control)：控制反转，依赖注入
依赖注入的三种实现类型(Spring支持后两种)：
- 接口注
Setter注入,如：
package com.michael.djh.User; public class User{ private String name; private Integer age; //Getter与Setter方法 ... } 则Spring的配置文件applicationContext.xml为： <bean name="user" class="com.michael.djh.User"> <property name="name"> <value>Michael</value> </property> <property name="age"> <value>20</value> </property> </bean> 主程序如下即可获取bean对象： Resource resource = new ClassPathResource("applicationContext.xml"); //load configuration file BeanFactory factory = new XmlBeanFactory(resource); User user = (User)factory.getBean("user"); //user.getName()、user.getAge()即可得到值- 构造器注入
- Spring中的自动装配方式：
- no属性：这是autowire采用的默认值,必须使用ref直接引用其他的bean
- constructor属性：通过构造方法的参数类型自动装配
- autodetect属性：会优先使用constructor方式来自动装配,然后使用byType方式
Srping 设置singleton模式的三种方式：(对bean请求方式类似于静态的getInstance()方法)
<bean id="test" class="com.michael.Test" /> //默认的即为singleton作用域 <bean id="test" class="com.michael.Test" singleton="true"/> <bean id="test" class="com.michael.Test" scopr="singleton"/>Spring IoC设置prototype的两种方式：(对bean的请求类似于new对象,每次都会重新创建一个新的)
<bean id="user" class="com.michale.User" singleton="false" /> //设置singleton的值为false <bean id="user" class="com.michael.User" scope="prototype" />Spring AOP:(面向切面编程)
- 切入点：依据切入点织入的位置不同，提供了以下三种类型的切入点：
- 静态切入点
- 动态切入点
- 其他切入点
静态切入点：需要在配置文件时指定,关键配置如下：
<bean id="pointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"> <ref bean="MyAdvisor" /> //指定通知 </property> <property name="patterns"> <list> <value>.*getConn*.</value> //指定所有以getConn开头的方法名都是切入点 <value>.*closeConn*.</value> </list> </property> <bean>- 静态切入点只能应用在相对不变的位置,而动态切入点应用在相对变化的位置
- 切入点：依据切入点织入的位置不同，提供了以下三种类型的切入点：
Spring的DAO理念：
- Spring DAO抽象提供了以下几种类：
- JdbcDaoSupport：需要设置数据源,通过子类,能够获得JdbcTemplate来访问数据库
- HibernateDaoSupport：需要设置Hibernate SessionFactory,通过子类能够获得Hibernate实现
Spring的配置文件applicationContext.xml的具体配置如下(以User类为例)：
<!-- 配置数据源 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://localhost:3306/db_michael</value> </property> <property name="username"> <value>root</value> </property> <property name="password"> <value>michael</value> </property> </bean> <!-- 为UserDAO注入数据 --> <bean id="userDAO" class="com.michael.dao.UserDAO"> <property name="dataSource"> <ref local="dataSource" /> </property> </bean>
- Spring DAO抽象提供了以下几种类：
事务应用管理：
编程式事务管理(两种实现方法：PlatformTransactionManager与TransactionTemplate(优先采用该方法)),配置文件如下：
<!-- 定义 TransactionTemplate模板 --> <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"> <property name="transactionManager"> <ref bean="transactionManager" /> </property> <property name="propagationBehaviorName"> <value>PROPAGATION_REQUIRED</value> </property> </bean> <!-- 定义事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.DataSourceTransactionTemplate"> <property name="dataSource"> <ref bean="dataSource" /> </property> </bean>- 声明式事务管理
JSP操作XML：(使用dom4j)
创建XML文档对象:
Document document = DocumentHelper.createDocument(); 或者 Document document = DocumentFactory.getInstance().createDocument();