电力系统技术总结笔记（10天）.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
