电力系统技术总结笔记（10天）(3).doc
蜗牛文库
-高品质阅读，高比例分成-
温馨提示：
1. 部分包含数学公式或PPT动画的文件，查看预览时可能会显示错乱或异常，文件下载后无此问题，请放心下载。
2. 本文档由用户上传，版权归属用户，汇文网负责整理代发布。如果您对本文档版权有争议请及时联系客服。
3. 下载前请仔细阅读文档内容，确认文档内容符合您的需求后进行下载，若出现内容与标题不符可向本站投诉处理。
4. 下载文档时可能由于网络波动等原因无法下载或下载错误，付费完成后未能成功下载的用户请联系客服处理。
网站客服：3074922707
1. 部分包含数学公式或PPT动画的文件，查看预览时可能会显示错乱或异常，文件下载后无此问题，请放心下载。
2. 本文档由用户上传，版权归属用户，汇文网负责整理代发布。如果您对本文档版权有争议请及时联系客服。
3. 下载前请仔细阅读文档内容，确认文档内容符合您的需求后进行下载，若出现内容与标题不符可向本站投诉处理。
4. 下载文档时可能由于网络波动等原因无法下载或下载错误，付费完成后未能成功下载的用户请联系客服处理。
网站客服：3074922707
电力系统
技术
总结
笔记
10
电力系统总结笔记
一：项目第一天（项目框架）
1：项目介绍
参考：《项目分析笔记》和【文档】中的《国家电力系统技术点汇总（简历使用）.doc》
2：项目框架（SSH）
第一步：创建数据库（格式：UTF-8）
创建表：
第二步：创建项目（格式：UTF-8）
导入jar包（SSH）
第三步：持久层
（1）在cn.itcast.elec.domain中创建ElecText.java
public class ElecText implements java.io.Serializable {
private String textID; //主键ID
private String textName; //测试名称
private Date textDate; //测试日期
private String textRemark; //测试备注
public String getTextID() {
return textID;
}
public void setTextID(String textID) {
this.textID = textID;
}
public String getTextName() {
return textName;
}
public void setTextName(String textName) {
this.textName = textName;
}
public Date getTextDate() {
return textDate;
}
public void setTextDate(Date textDate) {
this.textDate = textDate;
}
public String getTextRemark() {
return textRemark;
}
public void setTextRemark(String textRemark) {
this.textRemark = textRemark;
}
}
（2）在cn.itcast.elec.domain目录下，创建ElecText.java对应的映射文件（ElecText.hbm.xml）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"
<hibernate-mapping>
<class name="cn.itcast.elec.domain.ElecText" table="Elec_Text">
<id name="textID" type="string" column="textID">
<generator class="uuid"></generator>
</id>
<property name="textName" type="string" column="textName"></property>
<property name="textDate" type="date" column="textDate"></property>
<property name="textRemark" type="string" column="textRemark"></property>
</class>
</hibernate-mapping>
（3）在src下创建hibernate.cfg.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"
<hibernate-configuration>
<session-factory>
<!-- 连接数据库的信息 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/itcastElec?useUnicode=true&characterEncoding=utf8</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 其他的配置 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
<!-- 加载映射文件 -->
<mapping resource="cn/itcast/elec/domain/ElecText.hbm.xml"/>
</session-factory>
</hibernate-configuration>
（4）使用junit在test包中进行测试（并且导入log4j的配置文件）
public class TestHibernate {
/**测试保存*/
@Test
public void save(){
Configuration configuration = new Configuration();
configuration.configure();//加载类路径hibernate.cfg.xml和映射文件
SessionFactory sf = configuration.buildSessionFactory();
Session s = sf.openSession();
Transaction tr = s.beginTransaction();
//测试操作对象的过程，就是操作数据库表
ElecText elecText = new ElecText();
elecText.setTextName("测试Hibernate名称");
elecText.setTextDate(new Date());
elecText.setTextRemark("测试Hibernate备注");
s.save(elecText);
mit();
s.close();
}
}
第四步：DAO层
（1）在cn.itcast.elec.dao中创建2个接口（公用接口和业务接口）
l 公用接口：
public interface ICommonDao<T> {
void save(T entity);
}
l 业务接口（需要继承公共接口，并且指定泛型T所对应的对象：
public interface IElecTextDao extends ICommonDao<ElecText> {
public static final String SERVICE_NAME = "cn.itcast.elec.dao.impl.ElecTextDaoImpl";
}
（2）在cn.itcast.elec.dao.impl中创建2个接口的实现类
l 公用类（需要继承HibernateDaoSupport，这样可以方便使用HibernateTemplate对象）：
public class CommonDaoImpl<T> extends HibernateDaoSupport implements ICommonDao<T> {
/**使用@Resource注入SessionFactory*/
@Resource(name="sessionFactory")
public final void setSessionFactoryDi(SessionFactory sessionFactory) {
this.setSessionFactory(sessionFactory);
}
/**保存*/
public void save(T entity) {
this.getHibernateTemplate().save(entity);
}
}
l 业务类（需要继承公用类，这样可以使用公用类中的定义的方法）
@Repository(IElecTextDao.SERVICE_NAME)
public class ElecTextDaoImpl extends CommonDaoImpl<ElecText> implements IElecTextDao {
}
（3）在src创建spring的配置文件(beans.xml)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<!-- 1：开启对注解的支持，组件的自动扫描，扫描在类上定义的@Controller @Service @Repositiry注解，范围是cn.itcast.elec的包 -->
<context:component-scan base-package="cn.itcast.elec"/>
<!-- 2:? 先不写，大家想想项目中应该添加什么？-->
<!-- 3:创建SessionFactory，这是spring整合hibernate的核心 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 加载类路径下的hibernate.cfg.xml -->
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 4:声明事务管理器(切面) -->
<bean id="trManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 5:注解，在Service的类或者是Service的方法上，添加@Transcational()注解,用来控制事务 -->
<tx:annotation-driven transaction-manager="trManager"/>
<!-- 也可以使用spring的配置文件的方式管理事务
<tx:advice id="aa" transaction-manager="trManager">
<tx:attributes>
<tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
<tx:method name="update*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
<tx:method name="delete*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut expression="execution(* cn.itcast.elec.service..*.*(..))" id="bb"/>
<aop:advisor advice-ref="aa" pointcut-ref="bb"/>
</aop:config>-->
</beans>
（4）使用junit完成测试
public class TestDao {
/**测试保存*/
@Test
public void save(){
//加载类路径下的spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
//调用接口
IElecTextDao elecTextDao = (IElecTextDao) ac.getBean(IElecTextDao.SERVICE_NAME);
//操作对象
ElecText elecText = new ElecText();
elecText.setTextName("测试Dao名称");
elecText.setTextDate(new Date());
elecText.setTextRemark("测试Dao备注");
elecTextDao.save(elecText);
}
}
注意：如果数据没有保存，需要设置事务自动提交：在hibernate.cfg.xml中添加：
<!-- 使用hibernate的方式提交事务（自动提交） -->
<property name="hibernate.connection.autocommit">true</property>
第五步：Service层
（1） 在cn.itcast.elec.service中创建接口：
public interface IElecTextService {
public static final String SERVICE_NAME = "cn.itcast.elec.service.impl.ElecTextServiceImpl";
void saveElecText(ElecText elecText);
}
（2） 在cn.itcast.elec.service.impl中创建接口的实现类：
@Service(IElecTextService.SERVICE_NAME)
@Transactional(readOnly=true)
public class ElecTextServiceImpl implements IElecTextService {
@Resource(name=IElecTextDao.SERVICE_NAME)
private IElecTextDao elecTextDao;
@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,readOnly=false)
public void saveElecText(ElecText elecText) {
elecTextDao.save(elecText);
}
}
（3） 使用junit测试
public class TestService {
/**测试保存*/
@Test
public void save(){
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
IElecTextService elecTextService = (IElecTextService) ac.getBean(IElecTextService.SERVICE_NAME);
//操作对象
ElecText elecText = new ElecText();
elecText.setTextName("测试Service名称");
elecText.setTextDate(new Date());
elecText.setTextRemark("测试Service备注");
elecTextService.saveElecText(elecText);
}
}
由于spring提供的声明式事务处理，进行事务的控制，在业务层的类和方法上定义@Transactional()，同时去掉hibernate.cfg.xml中的配置，由spring统一控制。去掉的代码是：
<!-- 使用hibernate的方式提交事务（自动提交） -->
<property name="hibernate.connection.autocommit">true</property>
第六步：控制层（ＭＶＣ）
（1）在cn.itcast.elec.web.action中创建Action（业务Action）类和BaseAction（公用Action）
l Action类：（注意：这里要设置成多例，即@Scope（value=prototype），因为struts2的Action是多实例，多线程）
@Controller("elecTextAction")
@Scope(value="prototype")
public class ElecTextAction extends BaseAction<ElecText>{
ElecText elecText = this.getModel();
@Resource(name=IElecTextService.SERVICE_NAME)
private IElecTextService elecTextService;
/**执行保存*/
public String save(){
//保存
elecTextService.saveElecText(elecText);
return "save";
}
}
l BaseAction类（封装模型驱动对象，HttpServletRequest和HttpServletResponse对象）：
public class BaseAction<T> extends ActionSupport implements ModelDriven<T>,ServletRequestAware,ServletResponseAware {
protected HttpServletRequest request;
protected HttpServletResponse response;
T entity;
public BaseAction(){
/**泛型转换成真实类型（范类转换）*/
Class entityClass = TUtils.getTClass(this.getClass());
try {
entity = (T) entityClass.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
public T getModel() {
return entity;
}
public void setServletRequest(HttpServletRequest req) {
this.request = req;
}
public void setServletResponse(HttpServletResponse res) {
this.response = res;
}
}
（2）在cn.itcast.elec.util包下创建公用类（泛型转换）。
泛型转换的目的子类传递真实对象类型，在父类中使用泛型转换成真实对象类型。
以后util包下封装的就是公用类。
public class TUtils {
/**泛型转换成真实类型（范类转换）*/
public static Class getTClass(Class entity) {
ParameterizedType parameterizedType = (ParameterizedType) entity.getGenericSuperclass();
Class entityClass = (Class) parameterizedType.getActualTypeArguments()[0];
return entityClass;
}
}
（3）在src下创建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"></constant>
<!-- 设置UI标签的主题 -->
<constant name="struts.ui.theme" value="simple"></constant>
<!-- 配置struts的URL访问的后缀，改成do（此处可以不修改，此时默认是.action） -->
<constant name="struts.action.extension" value="do"></constant>
<!-- 系统管理 -->
<package name="system" namespace="/system" extends="struts-default">
<action name="elecTextAction_*" class="elecTextAction" method="{1}">
<result name="save">/system/textAdd.jsp</result>
</action>
</package>
</struts>
（4）在web.xml中添加配置：
<web-app version="2.5"
xmlns="
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
<display-name></display-name>
<!-- 配置struts2的过滤器，这是struts2运行的核心 -->
<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容器启动的时候，自动加载spring容器（监听器） -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
（5）导入css，script，jsp，images进行测试
使用system/textAdd.jsp进行测试：页面如图
点击【保存】完成。测试保存ElecText对象。
SSH整体架构图：
3：底层方法封装（CommonDaoImpl类）
public class CommonDaoImpl<T> extends HibernateDaoSupport implements ICommonDao<T> {
/**泛型转换，获取真实对象实体*/
Class entityClass = TUtils.getTClass(this.getClass());
/**使用@Resource注入SessionFactory*/
@Resource(name="sessionFactory")
public final void setSessionFactoryDi(SessionFactory sessionFactory) {
this.setSessionFactory(sessionFactory);
}
/**保存*/
public void save(T entity) {
this.getHibernateTemplate().save(entity);
}
/**更新*/
public void update(T entity) {
this.getHibernateTemplate().update(entity);
}
/**使用主键ID，查询对象*/
public T findObjectByID(Serializable id) {
return (T) this.getHibernateTemplate().get(entityClass, id);
}
/**使用主键ID，删除对象（删除一个或者多个对象）*/
public void deleteObjectByIDs(Serializable... ids) {
if(ids!=null && ids.length>0){
for(Serializable id:ids){
Object entity = this.findObjectByID(id);
this.getHibernateTemplate().delete(entity);
}
}
}
/**使用封装对象的集合，批量删除对象*/
public void deleteObjectByCollection(List<T> list) {
this.getHibernateTemplate().deleteAll(list);
}
/**测试指定查询条件，查询结果集（不分页）*/
/**
这里1=1的目的是方便在Service层拼装sql或者hql语句，连接统一使用and
* SELECT o FROM ElecText o WHERE 1=1 #Dao层填写
AND o.textName LIKE '%张%' #Service拼装
AND o.textRemark LIKE '%张%' #Service拼装
ORDER BY o.textDate ASC,o.textName desc #Service拼装
*/
public List<T> findCollectionByConditionNoPage(String condition,
final Object[] params, Map<String, String> orderby) {
String hql = "SELECT o FROM "+entityClass.getSimpleName()+" o WHERE 1=1";
String orderByHql = this.initOrderByHql(orderby);
final String finalHql = hql + condition + orderByHql;
//执行hql语句
/**方式一：直接使用HibernateTemplate的find()方法，find方法支持执行hql语句*/
// List<T> list = this.getHibernateTemplate().find(finalHql, params);
/**方式二：获取SessionFactory，在获取Session*/
// SessionFactory sf = this.getHibernateTemplate().getSessionFactory();
// Session s = sf.getCurrentSession();
// Query query = s.createQuery(finalHql);
// query.setParameter(0, params[0]);
// query.setParameter(1, params[1]);
// List<T> list = query.list();
/**方式三：使用hibernateTemplate调用回调函数*/
List<T> list = this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(finalHql);
if(params!=null && params.length>0){
for(int i=0;i<params.length;i++){
query.setParameter(i, params[i]);
}
}
return query.list();
}
});
return list;
}
/**组织排序语句，将Map集合转换成String类型*/
private String initOrderByHql(Map<String, String> orderby) {
StringBuffer buffer = new Stri
