个人知识管理系统Version1.0开发记录（11）

关 键 字 搜 索

（1）匹配单个属性的关键字；（2）匹配单个对象的关键字；（3）匹配对象集合的关键字；（4）基于事件驱动的；（5）实时搜索，参考win7的搜索功能。

1、备份，java代码，数据库数据。

2、oracle数据库，用户操作。

（1）查看数据库默认表空间。
select * from database_properties;
（2）创建用户
create user 用户名 identified by 密码 默认表空间 临时表空间
create user dyl identified by dyl default tablespace users Temporary TABLESPACE Temp;
（3）授权用户
grant connect,resource,dba to dyl;
（4）提交
commit;
（5）查询用户
select * from all_users;
select username,password from dba_users;

3、oracle数据库，oneds表添加主键，实现主键自增长。

（1）表-》约束条件-》添加主键。（2）序列-》新建序列。（3）表-》触发器-》创建序列中的主键。

4、 数据持久层用hibernate实现，定义 oneds 表和 OneDs 类型之间的映射信息。

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4
 5 <!-- 定义 oneds 表和 OneDs 类型之间的映射信息 -->
 6 <hibernate-mapping><!-- <hibernate-mapping package="包名写这也行"> -->
 7     <!-- name：包名.类名，指定是哪个类；table：数据库中哪个表；catalog：对 Oracle 而言 为某个用户，不写也行（若用工具则会自动生成）
 8         。 例如， select * from oneds 则会在 hibernate.cfg 配置 文件中定义的库（或用户）下去找表。若写了则为 select
 9         * from catalog.oneds -->
10
11     <class name="com.dyl.entity.OneDs" table="ONEDS" catalog="DYL">
12
13         <!-- <id></id>表明此为主键列，且必须写否则 xml 报错，主键映射 -->
14         <id name="id" type="java.lang.Integer">
15             <column name="ID" /><!-- 或双标签<column name="ID"></column> -->
16             <!-- 指定主键值生成方式，采用序列方式生成主键，仅对添加操作有效 -->
17             <generator class="sequence">
18                 <param name="sequence">ONEDS_SEQUENCE</param> <!--指定序列名 -->
19             </generator>
20         </id>
21
22         <property name="name" type="java.lang.String"><!-- 以下为非主键映射 -->
23             <column name="NAME" /><!--可有 length、not-null 属性，如：length="20" -->
24         </property>
25         <property name="remark" type="java.lang.String"><!-- 映射顺序没关系 -->
26             <column name="REMARK" />
27         </property>
28         <property name="definition" type="java.lang.String"><!-- 类型要和实体定义的相同 -->
29             <column name="DEFINITION" />
30         </property>
31         <property name="attribute" type="java.lang.String"><!--列名写错则报错读不到实体 -->
32             <column name="ATTRIBUTE" /><!--junit 测试右键点 Copy Trace 查看错误列 -->
33         </property>
34         <property name="method" type="java.lang.String">
35             <column name="METHOD" />
36         </property>
37         <property name="dscase" type="java.lang.String">
38             <column name="DSCASE" />
39         </property>
40         <property name="explain" type="java.lang.String">
41             <column name="EXPLAIN" />
42         </property>
43
44         <!--也可写成<property name=" " type=" " column=" "></property> ，主键列同理！ -->
45
46     </class>
47 </hibernate-mapping>

OneDs.hbm.xml

5、hibernata管家。

 1 <?xml version=‘1.0‘ encoding=‘UTF-8‘?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7
 8         <property name="dialect"><!-- 指定方言，决定 Hibernate 生成哪种 SQL -->
 9             org.hibernate.dialect.OracleDialect<!-- 不知道数据库版本就写 OracleDialect -->
10         </property><!-- 可在 hibernate3.jar 中 org.hibernate.dialect 包下查看名字 -->
11
12         <property name="connection.url">
13             jdbc:oracle:thin:@192.168.0.106:1521:PKMS
14         </property>
15         <property name="connection.username">DYL</property>
16         <property name="connection.password">DYL</property>
17         <property name="connection.driver_class">
18             oracle.jdbc.driver.OracleDriver
19         </property>
20
21         <!-- 框架参数，将 hibernate 底层执行的 SQL 语句从控制台显示 -->
22         <property name="show_sql">true</property>
23         <!-- 格式化显示的 SQL -->
24         <property name="format_sql">true</property>
25         <!-- 指定映射描述文件 -->
26         <mapping resource="com/dyl/entity/OneDs.hbm.xml" />
27
28     </session-factory>
29 </hibernate-configuration>

hibernate.cfg.xml

6、dao接口，没有本质变化。

 1 package com.dyl.dao;
 2
 3 import java.util.List;
 4
 5 import com.dyl.entity.OneDs;
 6 /**
 7  * 知识点dao接口
 8  * @author dyl
 9  * @date 2014-7-26
10  */
11 public interface IOneDsDao {
12     public void addOneDs(OneDs od);
13     public void deleteOneDs(int id);
14     public void updateOneDs(OneDs od);
15     public OneDs selectById(int id);
16     public List<OneDs> selectAll();
17     /**
18      * 根据名称模糊查询
19      */
20     public List<OneDs>selectByName(String name);
21 }

IOneDsDao

7、dao实现。

  1 package com.dyl.dao.impl;
  2
  3 import java.util.List;
  4
  5 import org.hibernate.Query;
  6 import org.hibernate.Session;
  7 import org.hibernate.Transaction;
  8
  9 import com.dyl.dao.IOneDsDao;
 10 import com.dyl.entity.OneDs;
 11 import com.dyl.util.HibernateUtil;
 12
 13 /**
 14  * 知识点数据持久实现
 15  *
 16  * @author dyl
 17  * @date 2014-7-26
 18  */
 19 public class OneDsDaoImpl implements IOneDsDao {
 20
 21     private Session session;
 22
 23     public OneDsDaoImpl() {// 不想老写获得 session 的方法，就写在构造器中
 24         session = HibernateUtil.getSession();
 25     }
 26
 27     /**
 28      * add 方法执行增加操作， 注意 1：获取事务并开启，增删改要注意，查询可以不管事 务，因为没对数据库进行修改； 注意 2：主键值根据
 29      * hbm.xml中的<generator>定义生成，执 行后，会先获取序列值，再去做 insert 操作。 即先：select
 30      * ONEDS_SEQUENCE.nextval from dual; 然后：insert into
 31      */
 32     public void addOneDs(OneDs od) {
 33         // Session session=HibernateUtil.getSession();
 34         Transaction tx = session.beginTransaction();// 打开事务
 35         session.save(od);
 36         tx.commit();// 提交事务
 37         session.close();// 释放
 38     }
 39
 40     /**
 41      * delete 方法执行删除操作，由于 Hibernate 以“对象”为单位进行数据库操作，所以
 42      * 这里要传进去一个对象，虽然是个对象，但还是按主键做条件删除，只要把主键值设置上就 行，其他非主键值不用管。也可先通过 id 查再删
 43      */
 44     public void deleteOneDs(int id) {
 45         // Session session=HibernateUtil.getSession();
 46         Transaction tx = session.beginTransaction();
 47         OneDs od = new OneDs();
 48         od.setId(id);
 49         session.delete(od);
 50         tx.commit();
 51         session.close();
 52     }
 53
 54     /** update 方法执行修改操作 */
 55     public void updateOneDs(OneDs od) {
 56         // Session session=HibernateUtil.getSession();
 57         Transaction tx = session.beginTransaction();
 58         session.update(od);// 将 oneds 对象更新到数据库
 59         tx.commit();
 60         session.close();
 61     }
 62
 63     /**
 64      * get 方法执行查询，按主键当条件查询，如何判断是主键，是根据写的描述文件来定， get 方法就是
 65      * selectById，就是按主键去查，需指定：操作哪个类和 id （主键）条件值即可，其他条件查询做不了
 66      */
 67     public OneDs selectById(int id) {
 68         // Session session=HibernateUtil.getSession();
 69         OneDs od = (OneDs) session.get(OneDs.class, id);
 70         //session.close();
 71         return od;
 72     }
 73
 74     /**
 75      * 特殊查询，SQL 语句：String sql="select * from oneds"; HQL 语句： String
 76      * hql="from OneDs"; （Hibernate Query Language） 是面向对象的查询语句。 from 后写映射的类名，它是
 77      * Hibernate 中特有的查询语句，根据映射的类去查询。
 78      */
 79     @SuppressWarnings("unchecked")
 80     public List<OneDs> selectAll() {
 81         // Session session=HibernateUtil.getSession();
 82         String hql = "from OneDs";// HQL 语句
 83         Query query = session.createQuery(hql);
 84         List<OneDs> list = query.list();// 执行查询，返回 List 集合
 85         session.close();
 86         return list;
 87     }
 88
 89     /**
 90      * 根据名称模糊查询
 91      */
 92     @SuppressWarnings("unchecked")
 93     public List<OneDs> selectByName(String name) {
 94         session.beginTransaction();
 95         // SQL代码
 96         String hql="from OneDs as od where od.name like :name";
 97         // 获取查询对象
 98         Query query = session.createQuery(hql);
 99         query.setString("name", "%" + name + "%");
100         List<OneDs> list = query.list();
101 //        for( int i = 0;  i < list.size();  i ++ ) {
102 //            OneDs od=list.get(i);
103 //            String odName=od.getName();
104 //            System.out.println("odName=" + odName);
105 //        }
106         session.getTransaction().commit();
107         session.close();
108         return list;
109     }
110 }

OneDsDaoImpl

8、junit测试。

 1 package com.dyl.dao.impl;
 2
 3 import java.util.List;
 4
 5 import org.junit.Test;
 6
 7 import com.dyl.dao.IOneDsDao;
 8 import com.dyl.entity.OneDs;
 9
10 /**
11  * junit测试
12  *
13  * @author dyl
14  * @date 2014-7-26
15  */
16 public class OneDsDaoImplTest {
17
18     @Test
19     public void testAdd() {// id 主键列由 Hibernate 管理，这里不用设置
20         IOneDsDao dao=new OneDsDaoImpl();
21         OneDs od = new OneDs();
22         od.setAttribute("1234567");
23         od.setDefinition("1234567");
24         od.setDscase("1234567");
25         od.setExplain("1234567");
26         od.setMethod("1234567");
27         od.setName("1234567");
28         od.setRemark("1234567");
29         dao.addOneDs(od);
30     }
31
32     @Test
33     public void testDelete() {
34         IOneDsDao dao=new OneDsDaoImpl();
35         dao.deleteOneDs(2);
36     }
37
38     @Test
39     public void testUpdate() {
40         /**
41          * 注意事项：更新部分字段，不能和实现类中的删除那样，做一个对象出来！否 则没设置的字段将被改为空！
42          */
43         IOneDsDao dao=new OneDsDaoImpl();
44         OneDs od = dao.selectById(1);// 只能先通过 id 找到带有所有值的对象
45         od.setAttribute("1234567");// 然后再对部分字段进行更新，才能避免把其他字段更新为空
46         od.setDefinition("1234567");
47         dao.updateOneDs(od);
48     }
49
50     @Test
51     public void testSelectById() {// 当 get 方法没有记录时，返回 null
52         IOneDsDao dao=new OneDsDaoImpl();
53         OneDs od = dao.selectById(1);
54         System.out.println(od.getAttribute());
55         System.out.println(od.getDefinition());
56         System.out.println(od.getDscase());
57         System.out.println(od.getExplain());
58         System.out.println(od.getMethod());
59     }
60
61     @Test
62     public void testFindAll() {
63         IOneDsDao dao=new OneDsDaoImpl();
64         List<OneDs> list = dao.selectAll();
65         for (OneDs od : list) {
66             System.out.println(od.getName());
67         }
68     }
69
70     @Test
71     public void testSelectByName(){
72         IOneDsDao dao=new OneDsDaoImpl();
73         String name="好";
74         List<OneDs>list=dao.selectByName(name);
75         for (OneDs od : list) {
76             System.out.println(od.getName());
77         }
78     }
79
80 }

OneDsDaoImplTest

9、工厂设计模式，没有本质变化。

 1 package com.dyl.util;
 2
 3 import com.dyl.dao.impl.CompanyDaoImpl;
 4 import com.dyl.dao.impl.DepDaoJdbcImpl;
 5 import com.dyl.dao.impl.DutyDaoJdbcImpl;
 6 import com.dyl.dao.impl.OneDsDaoImpl;
 7 import com.dyl.dao.impl.StaffDaoImpl;
 8 /**
 9  * 工厂设计模式：为调用者提供符合接口要求的对象,方便我们以后采用框架技术进行底层数据访问。
10  * @author dyl
11  * @date 2014-06-01
12  */
13 public class Factory {
14     public static Object getInstance(String type) {
15         Object obj = null;
16         if ("IOneDsDAO".equals(type)) {
17             obj = new OneDsDaoImpl();
18
19         } else if ("ICompanyDao".equals(type)) {
20             obj = new CompanyDaoImpl();
21
22         } else if ("IDepDao".equals(type)) {
23             obj = new DepDaoJdbcImpl();
24         } else if ("IDutyDao".equals(type)) {
25             obj = new DutyDaoJdbcImpl();
26
27         } else if ("IStaffDao".equals(type)) {
28             obj = new StaffDaoImpl();
29         }
30
31         return obj;
32     }
33 }

Factory

10、业务逻辑接口，没有本质变化。

 1 package com.dyl.service;
 2
 3 import java.util.List;
 4
 5 import com.dyl.entity.OneDs;
 6
 7 /**
 8  * 知识点业务逻辑接口
 9  * @author dyl
10  * @date 2014-7-26
11  */
12 public interface IOneDsService {
13     public void addOneDs(OneDs od);
14     public void deleteOneDs(int id);
15     public void updateOneDs(OneDs od);
16     public OneDs selectById(int id);
17     public List<OneDs> selectAll();
18
19     /**
20      * 根据名称模糊查询
21      */
22     public List<OneDs>selectByName(String name);
23 }

IOneDsService

11、业务逻辑实现，没有本质变化。

 1 package com.dyl.service.impl;
 2
 3 import java.util.List;
 4
 5 import com.dyl.dao.IOneDsDao;
 6 import com.dyl.entity.OneDs;
 7 import com.dyl.service.IOneDsService;
 8 import com.dyl.util.Factory;
 9
10 /**
11  * 知识点业务逻辑实现
12  * @author dyl
13  * @date 2014-7-26
14  */
15 public class OneDsServiceImpl implements IOneDsService{
16
17     IOneDsDao dao=(IOneDsDao) Factory.getInstance("IOneDsDAO");
18
19     public void addOneDs(OneDs od) {
20         dao.addOneDs(od);
21     }
22
23     public void deleteOneDs(int id) {
24         dao.deleteOneDs(id);
25     }
26
27     public void updateOneDs(OneDs od) {
28         dao.updateOneDs(od);
29     }
30
31     public OneDs selectById(int id) {
32         return dao.selectById(id);
33     }
34
35     public List<OneDs> selectAll() {
36         return dao.selectAll();
37     }
38
39     /**
40      * 根据名称模糊查询
41      */
42     public List<OneDs>selectByName(String name){
43         return dao.selectByName(name);
44     }
45 }

OneDsServiceImpl

12、导入struts2框架和json数据交换格式需要用到的jar包。

13、在web.xml中，配置struts2前端控制器。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 5     id="WebApp_ID" version="2.5">
 6     <display-name></display-name>
 7     <welcome-file-list>
 8         <welcome-file>index.html</welcome-file>
 9         <welcome-file>index.htm</welcome-file>
10         <welcome-file>index.jsp</welcome-file>
11         <welcome-file>default.html</welcome-file>
12         <welcome-file>default.htm</welcome-file>
13         <welcome-file>default.jsp</welcome-file>
14     </welcome-file-list>
15
16     <filter><!-- 前端控制器 -->
17         <filter-name>Struts2</filter-name>
18         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
19     </filter>
20
21     <filter-mapping>
22         <filter-name>Struts2</filter-name>
23         <url-pattern>/*</url-pattern><!-- 表示所有的请求都要经过该过滤器 -->
24     </filter-mapping>
25
26 </web-app>

web.xml

14、基础action，提供一些基本的公共功能。

  1 package com.dyl.util;
  2
  3 import java.io.IOException;
  4 import java.io.PrintWriter;
  5 import javax.servlet.ServletContext;
  6 import javax.servlet.http.HttpServletRequest;
  7 import javax.servlet.http.HttpServletResponse;
  8 import javax.servlet.http.HttpSession;
  9
 10 import net.sf.json.JSONArray;
 11 import net.sf.json.JSONObject;
 12
 13 import org.apache.struts2.ServletActionContext;
 14 // class BaseAction extends ActionSupport implements ServletRequestAware,ServletResponseAware,ServletContextAware
 15
 16 import com.opensymphony.xwork2.ActionSupport;
 17
 18 /**
 19  * 基础action,提供一些基本的公共功能。
 20  *
 21  * Action接口有:
 22  * public static final java.lang.String SUCCESS = "success";
 23  * public static final java.lang.String NONE = "none";
 24  * public static final java.lang.String ERROR = "error";
 25  * public static final java.lang.String INPUT = "input";
 26  * public static final java.lang.String LOGIN = "login";
 27  * public abstract java.lang.String execute() throws java.lang.Exception;
 28  *
 29  * extends ActionSupport
 30  *
 31  * 由JavaDoc可知，ActionSupport类实现了接口:
 32  * com.opensymphony.xwork2.Action。
 33  * com.opensymphony.xwork2.LoaleProvider。
 34  * com.opensymphony.xwork2.TextProvider。
 35  * com.opensymphony.xwork2.Validateable。
 36  * com.opensymphony.xwork2.ValidationAware。
 37  * com.uwyn.rife.continuations.ContinuableObject。
 38  * java.io.Serializable。
 39  * java.lang.Cloneable。
 40  *
 41  * 例如：（1）数据校验。Actionsupport这个工具类在实现了Action接口的基础上还定义了一个validate()方法，重写该方法，
 42  * 它会在execute()方法之前执行，如校验失败，会转入input处，必须在配置该Action时配置input属性。
 43  * 例如：（2）实现国际化。Actionsupport提供了一个getText(String key)方法实现国际化，该方法从资源文件上获取国际化信息。
 44  * 这样在自定义标签时可以定义一个变量为new actionsupport对象实现国际化。
 45  * 例如：（3）序列化。class ActionSupport implements java.io.Serializable
 46  *
 47  * @author dyl
 48  * @date 2014-7-12
 49  */
 50 public class BaseAction extends ActionSupport {
 51     private static final long serialVersionUID = 184151487358146406L;
 52
 53     /**
 54      * 发送字符串
 55      *
 56      * out.write()是字节输出流的方法
 57      * out.print()是字符输出流的方法
 58      * servelt中是HttpServletResponse.getWriter()取得的字符输出流
 59      * jsp隐式变量out是字符输出流
 60      * @param str
 61      */
 62     public void outString(String str) {
 63         try {
 64             PrintWriter out = getResponse().getWriter();
 65             // out.write(str);
 66             out.print(str);
 67         } catch (IOException e) {
 68             e.printStackTrace();
 69         }
 70     }
 71
 72     /**
 73      * 发送xml数据
 74      *
 75      * Tomcat的安装目录\conf\web.xml 中就定义了大量MIME类型 ，可以参考。
 76      * response.setContentType("text/html; charset=utf-8"); html
 77      * response.setContentType("text/plain; charset=utf-8"); 文本
 78      * response.setContentType("text/javascript; charset=utf-8"); json数据
 79      * response.setContentType("application/xml; charset=utf-8"); xml数据
 80      * @param xmlStr
 81      */
 82     public void outXMLString(String xmlStr) {
 83         getResponse().setContentType("application/xml;charset=UTF-8");// 指定对服务器响应进行重新编码的编码
 84         outString(xmlStr);
 85     }
 86
 87     /**
 88      * 发送json数据
 89      *
 90      * Tomcat的安装目录\conf\web.xml 中就定义了大量MIME类型 ，可以参考。
 91      * response.setContentType("text/html; charset=utf-8"); html
 92      * response.setContentType("text/plain; charset=utf-8"); 文本
 93      * response.setContentType("text/javascript; charset=utf-8"); json数据
 94      * response.setContentType("application/xml; charset=utf-8"); xml数据
 95      * @param xmlStr
 96      */
 97     public void outJsonString(String str) {
 98         getResponse().setContentType("text/javascript;charset=UTF-8");// 设置发送到客户端的响应的内容类型
 99         outString(str);
100     }
101
102     /**
103      * Java对象转换成一个JSON字符串，使用JSONObject.fromObject()
104      *
105      * @param obj
106      */
107     public void outJson(Object obj) {
108         outJsonString(JSONObject.fromObject(obj).toString());
109     }
110
111     /**
112      * Java对象组成的集合转换成一个JSON字符串，使用JSONArray.fromObject()
113      *
114      * @param objs
115      */
116     public void outJsonArray(Object objs) {
117         outJsonString(JSONArray.fromObject(objs).toString());
118     }
119
120     /**
121      * 获得request
122      *
123      * ServletActionContext返回的是Servlet使用类型
124      * @return
125      */
126     public HttpServletRequest getRequest() {
127         return ServletActionContext.getRequest();
128     }
129
130     /**
131      * 获得response
132      *
133      * ServletActionContext返回的是Servlet使用类型
134      * @return
135      */
136     public HttpServletResponse getResponse() {
137         return ServletActionContext.getResponse();
138     }
139
140     /**
141      * 获得session
142      *
143      * 后台：HttpSession session = request.getSession();
144      * @return
145      */
146     public HttpSession getSession() {
147         return getRequest().getSession();
148     }
149
150     /**
151      * 获得servlet上下文
152      *
153      * ServletActionContext返回的是Servlet使用类型
154      *
155      * 后台：ServletContext servletContext = this.getServletContext();
156      *         servletContext.setAttribute(("username",username);
157      * JSP网页：application.getAttribute("username");
158      * @return
159      */
160     public ServletContext getServletContext() {
161         return ServletActionContext.getServletContext();
162     }
163
164     /**
165      * 获得绝对路径
166      * request.getSession().getServletContext().getRealPath("/")+"";
167      *
168      * 比较：获得相对路径，request.getContextPath()
169      * @param path
170      * @return
171      */
172     public String getRealPath(String path) {
173         return getServletContext().getRealPath(path);
174     }
175
176 }

BaseAction

15、Action类。

 1 package com.dyl.action;
 2
 3 import java.util.List;
 4 import com.dyl.entity.OneDs;
 5 import com.dyl.service.IOneDsService;
 6 import com.dyl.service.impl.OneDsServiceImpl;
 7 import com.dyl.util.BaseAction;
 8
 9 /**
10  * 知识点控制器
11  *
12  * @author dyl
13  * @date 2014-7-27
14  */
15 public class OneDsAction extends BaseAction {
16
17     private static final long serialVersionUID = 3518833679938898354L;
18
19     private List<OneDs> odList; // 使用josn返回List对象
20
21     // 为上面的的属性提供get，Set方法
22     public List<OneDs> getOdList() {
23         return odList;
24     }
25
26     public void setOdList(List<OneDs> odList) {
27         this.odList = odList;
28     }
29
30     /**
31      * 返回List对象
32      *
33      * @return
34      */
35     public String returnList() {
36
37         String name = super.getRequest().getParameter("odName");
38         //System.out.println(name);
39         IOneDsService ds = new OneDsServiceImpl();
40         odList = ds.selectByName(name);
41 //        for (int i = 0; i < odList.size(); i++) {
42 //            System.out.println(odList.get(i).getName());
43 //        }
44
45         return "list";
46     }
47
48 }

OneDsAction

16、控制器配置文件struts.xml。

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE struts PUBLIC
 3     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
 4     "http://struts.apache.org/dtds/struts-2.0.dtd">
 5
 6 <struts>
 7
 8     <package name="default" namespace="/" extends="json-default">
 9         <action name="OneDsAction" class="com.dyl.action.OneDsAction">
10
11             <!-- 返回List对象 -->
12             <result name="list" type="json"></result>
13
14         </action>
15     </package>
16
17 </struts>  

struts.xml

17、显示界面。

 1 <!DOCTYPE HTML>
 2
 3 <html>
 4 <head>
 5
 6 <title>知识点</title>
 7
 8 <meta charset="utf-8">
 9
10 <script src="js/jquery.js"></script>
11 <script src="js/index.js"></script>
12
13 </head>
14
15 <body>
16
17     <input id="odName" type="text" value="输出名称关键字进行查询"
18         onfocus="if (value ==‘输出名称关键字进行查询‘){value =‘‘}"
19         onblur="if (value ==‘‘){value=‘输出名称关键字进行查询‘}" />
20     <input id="selectOdName" type="button" value="查询" />
21     <br />
22     <br />
23     <!-- 信息层 -->
24     <div id="message"></div>
25
26 </body>
27 </html>

index.html

18、事件驱动。

 1 //初始加载页面时
 2 $(document).ready(
 3         function() {
 4
 5             // 为按钮添加鼠标单击事件
 6             $("#selectOdName").click(
 7                     function() {
 8
 9                         var odName=document.getElementById("odName").value;
10                         //alert(odName);
11
12                         // 使用jQuery中的$.ajax({});Ajax方法
13                         $.ajax({
14                             url : "OneDsAction!returnList.action",
15                             type : "POST",
16                             data : {odName:odName},
17                             dataType : "json",
18                             success : function(data) {
19                                 //alert(data);
20                                 // 查看Object对象内容
21                                 for(i in data){
22                                     //alert(i);        // 获得属性
23                                     //alert(data[i]); // 获得属性值
24                                 }
25 //                                alert(data.odList);
26 //                                var test=data.odList;
27 //                                for(j in test){
28 //                                    alert(j);
29 //                                    alert(test[j]);
30 //                                    var b=test[j];
31 //                                    for(k in b){
32 //                                        alert(k);
33 //                                        alert(b[k]);
34 //                                    }
35 //                                }
36
37                                 // 清空显示层中的数据
38                                 $("#message").html("");
39                                 // 使用jQuery中的each(data,function(){});函数
40                                 // 从data.odList获取OneDs对象放入value之中
41                                 $.each(data.odList, function(i, value) {
42 //                                    alert(i);
43 //                                    alert(value.name);
44                                     $("#message").append("<div>第" + (i + 1) + "个：</div>")
45                                             .append("<div><font color=‘red‘>编号：" + value.id + "</font></div>")
46                                             .append("<div><font color=‘red‘>名称：" + value.name + "</font></div>")
47                                             .append("<div><font color=‘red‘>简介：" + value.remark + "</font></div>")
48                                             .append("<div><font color=‘red‘>定义：" + value.definition + "</font></div>")
49                                             .append("<div><font color=‘red‘>属性：" + value.attribute + "</font></div>")
50                                             .append("<div><font color=‘red‘>方法：" + value.method + "</font></div>")
51                                             .append("<div><font color=‘red‘>实例：" + value.dscase + "</font></div>")
52                                             .append("<div><font color=‘red‘>说明：" + value.explain + "</font></div>");
53                                 });
54                             }
55                         });
56
57                     });
58
59         });

index.js

19、tomcat加入系统服务，方便tomcat应用自动启动，tomcat应用编译好后放在webapps里。修改xml配置文件，需要重新编译，eclipse->project->clean。

（1）进入D:/ProgramFiles/Tomcat6/bin目录，找到startup.bat、shutdown.bat、service.bat。

（2）修改startup.bat

在第一行前加入如下内容:
SET JAVA_HOME=D:\ProgramFiles\tool\Java\jdk6
SET CATALINA_HOME=D:\ProgramFiles\Tomcat6
JAVA_HOME就是环境变量中配置的内容.CATALINA_HOME就是Tomcat的目录

（3）修改shutdown.bat
在第一行前加入如下内容:
SET JAVA_HOME=D:\ProgramFiles\tool\Java\jdk6
SET CATALINA_HOME=D:\ProgramFiles\Tomcat6

（4）修改service.bat
在第一行前加:
set CATALINA_HOME=D:\ProgramFiles\Tocmat6
set SERVICE_NAME=Tomcat6
set PR_DISPLAYNAME=Apache Tomcat
第一行是环境变量中配置的内容,第二行是服务的名字,在命令行中通过该名字进行服务的控制(启动/关闭)
第三行是服务的显示名称,即在服务管理器中显示的名称.

（5）添加服务
在DOS界面下,进入Tomcat解压目录的bin目录,输入命令:
service remove tomcat6
service.bat install
如果安装成功,会提示:The service ‘Tomcat6（或者修改后的SERVICE_NAME）‘ has been installed

20、设置链接到桌面，避免每次输出。桌面右键新建-》快捷方式-》输入url和名称。

21、工程结构图。

个人知识管理系统Version1.0开发记录（11）