createTree(1, orgNodeTree, sameOrgNodes, 0);


@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class NodeTree {
    private  String pName;
    private  String name;
    private  int level;
    private List<NodeTree> children;
}

private void createTree(int leave, int ind, Map<String, NodeTree> pIndexNodeNameMap, List<NodeVo> childNodes) {
     Map<String, NodeTree> cIndexNodeNameMap = new HashMap();
     //构建树
     int treeNo = pIndexNodeNameMap.size();
     if (treeNo == 0) {
         return;
     }
     int group = 0;
     for (int i = ind; i < childNodes.size(); i++) {
         NodeVo node = childNodes.get(i);
         long index = node.getId() % treeNo;
         NodeTree pNode = pIndexNodeNameMap.get(index + "");
         List<NodeTree> children = pNode.getChildren();
         if (CollectionUtils.isEmpty(children)) {
             children = new ArrayList();
         }
         if (children.size() > 2) {
             leave++;
             createTree(leave, i, cIndexNodeNameMap, childNodes);
             break;
         } else {
             NodeTree child = new NodeTree();
             child.setLevel(leave);
             child.setPName(pNode.getName());
             child.setName(node.getNodeName());
             children.add(child);
             pNode.setChildren(children);
             cIndexNodeNameMap.put(group + "", child);
             group++;
         }
     }
 }


private boolean createTree(int level, List<NodeTree> parentNodes, List<NodeVo> childNodes, int beginIndex) {
    //构建树
    List<NodeTree> nextLevelNodes = new ArrayList<>();
    for (int i = beginIndex; i < childNodes.size(); i++) {
        int parentCount = 1;
        for (NodeTree pNode : parentNodes) {
            List<NodeTree> children = pNode.getChildren();
            if (CollectionUtils.isEmpty(children)) {
                children = new ArrayList();
                pNode.setChildren(children);
            }
            if (children.size() >= 3) {
                if(parentCount >= parentNodes.size()){
                    return createTree(++level, nextLevelNodes, childNodes, beginIndex);
                }
            } else {
                if (beginIndex >= childNodes.size()) {
                    return true;
                }
                NodeTree child = new NodeTree();
                child.setLevel(level);
                child.setPName(pNode.getName());
                NodeVo node = childNodes.get(beginIndex);
                child.setName(node.getNodeName());
                pNode.getChildren().add(child);
                nextLevelNodes.add(child);
                beginIndex++;
            }
            parentCount++;
        }
    }
    return true;
}

进入“控制面板”——“用户账户”-凭据管理器——windows凭据

找到了git的用户名密码。修改正确后ok

元注解：

　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：
　　　　1.@Target,
　　　　2.@Retention,
　　　　3.@Documented,
　　　　4.@Inherited

@Target(TYPE)
@Retention(RUNTIME)
public @interface Table {
    /**
     * (Optional) The name of the table.
     * <p/>
 * Defaults to the entity name.
     */
 String name() default "";
}

@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Column {

    /**
     * (Optional) The name of the column. Defaults to
     * the property or field name.
     */
 String name() default "";
}

@Table(name = "t_s_user")
public class User {
    @Column(name="name")
    private String name;

 @Column(name="pwd")
    private String pwd;

    public String getName() {
        return name;
 }

    public void setName(String name) {
        this.name = name;
 }

    public String getPwd() {
        return pwd;
 }

    public void setPwd(String pwd) {
        this.pwd = pwd;
 }
}

public static void print() {
  System.out.println("table's name：" + User.class.getAnnotation(Table.class).name());
 Field[] fields = User.class.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];
 System.out.println("field's type:" + field.getType().getName());
 System.out.println("field's columnName:" + field.getAnnotation(Column.class).name());
 }
}

@SpringBootApplication
@ComponentScan
@Import({DBConfiguration.class, ResourceConfiguration.class,AppConfiguration.class})
public class Application extends SpringBootServletInitializer {
    @Override
 protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
 }

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-tomcat</artifactId>
           <scope>provided</scope>
       </dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-legacy</artifactId>
   <version>1.0.2.RELEASE</version>
</dependency>

<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.0.1</version>
</dependency>
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.0.1</version>
</dependency>

<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.1</version>
</dependency>

Spring Data JDBC generic DAO implementation

The purpose of this project is to provide generic, lightweight and easy to use DAO implementation for relational databases based on JdbcTemplate from Spring framework, compatible with Spring Data umbrella of projects.

Design objectives

• Lightweight, fast and low-overhead. Only a handful of classes, no XML, annotations, reflection
• This is not full-blown ORM. No relationship handling, lazy loading, dirty checking, caching
• CRUD implemented in seconds
• For small applications where JPA is an overkill
• Use when simplicity is needed or when future migration e.g. to JPA is considered
• Minimalistic support for database dialect differences (e.g. transparent paging of results)

Features

Each DAO provides built-in support for:

• Mapping to/from domain objects through RowMapper abstraction
• Generated and user-defined primary keys
• Extracting generated key
• Compound (multi-column) primary keys
• Immutable domain objects
• Paging (requesting subset of results)
• Sorting over several columns (database agnostic)
• Optional support for many-to-one relationships
• Supported databases (continuously tested):
  • MySQL
  • PostgreSQL
  • H2
  • HSQLDB
  • Derby
  • MS SQL Server (2008, 2012)
  • Oracle 10g / 11g (9i should work too)
  • ...and most likely many others
• Easily extendable to other database dialects via SqlGenerator class.
• Easy retrieval of records by ID

API

Compatible with Spring Data PagingAndSortingRepository abstraction, all these methods are implemented for you:

public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
 T  save(T entity);
Iterable<T> save(Iterable<? extends T> entities);
 T  findOne(ID id);
boolean exists(ID id);
Iterable<T> findAll();
   long count();
   void delete(ID id);
   void delete(T entity);
   void delete(Iterable<? extends T> entities);
   void deleteAll();
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pageable);
Iterable<T> findAll(Iterable<ID> ids);
}

Pageable and Sort parameters are also fully supported, which means you get paging and sorting by arbitrary properties for free. For example say you have userRepository extending PagingAndSortingRepository<User, String> interface (implemented for you by the library) and you request 5th page of USERS table, 10 per page, after applying some sorting:

Page<User> page = userRepository.findAll(
new PageRequest(
5, 10, 
new Sort(
new Order(DESC, "reputation"), 
new Order(ASC, "user_name")
)
)
);

Spring Data JDBC repository library will translate this call into (PostgreSQL syntax):

SELECT *
FROM USERS
ORDER BY reputation DESC, user_name ASC
LIMIT 50 OFFSET 10

...or even (Derby syntax):

SELECT * FROM (
SELECT ROW_NUMBER() OVER () AS ROW_NUM, t.*
FROM (
SELECT * 
FROM USERS 
ORDER BY reputation DESC, user_name ASC
) AS t
) AS a 
WHERE ROW_NUM BETWEEN 51 AND 60

No matter which database you use, you'll get Page<User> object in return (you still have to provide RowMapper<User> yourself to translate from ResultSet to domain object). If you don't know Spring Data project yet, Page<T> is a wonderful abstraction, not only encapsulating List<T>, but also providing metadata such as total number of records, on which page we currently are, etc.

Reasons to use

• You consider migration to JPA or even some NoSQL database in the future.

  Since your code will rely only on methods defined in PagingAndSortingRepository and CrudRepository from Spring Data Commons umbrella project you are free to switch from JdbcRepository implementation (from this project) to: JpaRepository, MongoRepository, GemfireRepository or GraphRepository. They all implement the same common API. Of course don't expect that switching from JDBC to JPA or MongoDB will be as simple as switching imported JAR dependencies - but at least you minimize the impact by using same DAO API.

• You need a fast, simple JDBC wrapper library. JPA or even MyBatis is an overkill

• You want to have full control over generated SQL if needed

• You want to work with objects, but don't need lazy loading, relationship handling, multi-level caching, dirty checking... You need CRUD and not much more

• You want to by DRY

• You are already using Spring or maybe even JdbcTemplate, but still feel like there is too much manual work

• You have very few database tables

Getting started

For more examples and working code don't forget to examine project tests.

Prerequisites

Maven coordinates:

<dependency>
<groupId>com.nurkiewicz.jdbcrepository</groupId>
<artifactId>jdbcrepository</artifactId>
<version>0.4</version>
</dependency>

This project is available under maven central repository.

Alternatively you can download source code as ZIP.

In order to start your project must have DataSource bean present and transaction management enabled. Here is a minimal MySQL configuration:

@EnableTransactionManagement
@Configuration
public class MinimalConfig {
@Bean
public PlatformTransactionManager transactionManager() {
return new DataSourceTransactionManager(dataSource());
}
@Bean
public DataSource dataSource() {
MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();
ds.setUser("user");
ds.setPassword("secret");
ds.setDatabaseName("db_name");
return ds;
}
}

Entity with auto-generated key

Say you have a following database table with auto-generated key (MySQL syntax):

CREATE TABLE COMMENTS (
id INT AUTO_INCREMENT,
user_name varchar(256),
contents varchar(1000),
created_time TIMESTAMP NOT NULL,
PRIMARY KEY (id)
);

First you need to create domain object User mapping to that table (just like in any other ORM):

public class Comment implements Persistable<Integer> {
private Integer id;
private String userName;
private String contents;
private Date createdTime;
@Override
public Integer getId() {
return id;
}
@Override
public boolean isNew() {
return id == null;
}
//getters/setters/constructors/...
}

Apart from standard Java boilerplate you should notice implementing Persistable<Integer> where Integer is the type of primary key. Persistable<T> is an interface coming from Spring Data project and it's the only requirement we place on your domain object.

Finally we are ready to create our CommentRepository DAO:

@Repository
public class CommentRepository extends JdbcRepository<Comment, Integer> {
public CommentRepository() {
super(ROW_MAPPER, ROW_UNMAPPER, "COMMENTS");
}
public static final RowMapper<Comment> ROW_MAPPER = //see below
private static final RowUnmapper<Comment> ROW_UNMAPPER = //see below
@Override
protected <S extends Comment> S postCreate(S entity, Number generatedId) {
entity.setId(generatedId.intValue());
return entity;
}
}

First of all we use @Repository annotation to mark DAO bean. It enables persistence exception translation. Also such annotated beans are discovered by CLASSPATH scanning.

As you can see we extend JdbcRepository<Comment, Integer> which is the central class of this library, providing implementations of all PagingAndSortingRepository methods. Its constructor has three required dependencies: RowMapper, RowUnmapper and table name. You may also provide ID column name, otherwise default "id" is used.

If you ever used JdbcTemplate from Spring, you should be familiar with RowMapper interface. We need to somehow extract columns from ResultSet into an object. After all we don't want to work with raw JDBC results. It's quite straightforward:

public static final RowMapper<Comment> ROW_MAPPER = new RowMapper<Comment>() {
@Override
public Comment mapRow(ResultSet rs, int rowNum) throws SQLException {
return new Comment(
rs.getInt("id"),
rs.getString("user_name"),
rs.getString("contents"),
rs.getTimestamp("created_time")
);
}
};

RowUnmapper comes from this library and it's essentially the opposite of RowMapper: takes an object and turns it into a Map. This map is later used by the library to construct SQL CREATE/UPDATE queries:

private static final RowUnmapper<Comment> ROW_UNMAPPER = new RowUnmapper<Comment>() {
@Override
public Map<String, Object> mapColumns(Comment comment) {
Map<String, Object> mapping = new LinkedHashMap<String, Object>();
mapping.put("id", comment.getId());
mapping.put("user_name", comment.getUserName());
mapping.put("contents", comment.getContents());
mapping.put("created_time", new java.sql.Timestamp(comment.getCreatedTime().getTime()));
return mapping;
}
};

If you never update your database table (just reading some reference data inserted elsewhere) you may skip RowUnmapper parameter or use MissingRowUnmapper.

Last piece of the puzzle is the postCreate() callback method which is called after an object was inserted. You can use it to retrieve generated primary key and update your domain object (or return new one if your domain objects are immutable). If you don't need it, just don't override postCreate().

Check out JdbcRepositoryGeneratedKeyTest for a working code based on this example.

By now you might have a feeling that, compared to JPA or Hibernate, there is quite a lot of manual work. However various JPA implementations and other ORM frameworks are notoriously known for introducing significant overhead and manifesting some learning curve. This tiny library intentionally leaves some responsibilities to the user in order to avoid complex mappings, reflection, annotations... all the implicitness that is not always desired.

This project is not intending to replace mature and stable ORM frameworks. Instead it tries to fill in a niche between raw JDBC and ORM where simplicity and low overhead are key features.

Entity with manually assigned key

In this example we'll see how entities with user-defined primary keys are handled. Let's start from database model:

CREATE TABLE USERS (
user_name varchar(255),
date_of_birth TIMESTAMP NOT NULL,
enabled BIT(1) NOT NULL,
PRIMARY KEY (user_name)
);

...and User domain model:

public class User implements Persistable<String> {
private transient boolean persisted;
private String userName;
private Date dateOfBirth;
private boolean enabled;
@Override
public String getId() {
return userName;
}
@Override
public boolean isNew() {
return !persisted;
}
public void setPersisted(boolean persisted) {
this.persisted = persisted;
}
//getters/setters/constructors/...
}

Notice that special persisted transient flag was added. Contract of [CrudRepository.save()](http://static.springsource.org/spring-data/data-commons/docs/current/api/org/springframework/data/repository/CrudRepository.html#save(S)) from Spring Data project requires that an entity knows whether it was already saved or not (isNew()) method - there are no separate create() and update() methods. Implementing isNew() is simple for auto-generated keys (see Comment above) but in this case we need an extra transient field. If you hate this workaround and you only insert data and never update, you'll get away with return true all the time from isNew().

And finally our DAO, UserRepository bean:

@Repository
public class UserRepository extends JdbcRepository<User, String> {
public UserRepository() {
super(ROW_MAPPER, ROW_UNMAPPER, "USERS", "user_name");
}
public static final RowMapper<User> ROW_MAPPER = //...
public static final RowUnmapper<User> ROW_UNMAPPER = //...
@Override
protected <S extends User> S postUpdate(S entity) {
entity.setPersisted(true);
return entity;
}
@Override
protected <S extends User> S postCreate(S entity, Number generatedId) {
entity.setPersisted(true);
return entity;
}
}

"USERS" and "user_name" parameters designate table name and primary key column name. I'll leave the details of mapper and unmapper (see source code). But please notice postUpdate() and postCreate() methods. They ensure that once object was persisted, persisted flag is set so that subsequent calls to save() will update existing entity rather than trying to reinsert it.

Check out JdbcRepositoryManualKeyTest for a working code based on this example.

Compound primary key

We also support compound primary keys (primary keys consisting of several columns). Take this table as an example:

CREATE TABLE BOARDING_PASS (
flight_no VARCHAR(8) NOT NULL,
seq_no INT NOT NULL,
passenger VARCHAR(1000),
seat CHAR(3),
PRIMARY KEY (flight_no, seq_no)
);

I would like you to notice the type of primary key in Persistable<T>:

public class BoardingPass implements Persistable<Object[]> {
private transient boolean persisted;
private String flightNo;
private int seqNo;
private String passenger;
private String seat;
@Override
public Object[] getId() {
return pk(flightNo, seqNo);
}
@Override
public boolean isNew() {
return !persisted;
}
//getters/setters/constructors/...
}

Unfortunately library does not support small, immutable value classes encapsulating all ID values in one object (like JPA does with @IdClass), so you have to live with Object[] array. Defining DAO class is similar to what we've already seen:

public class BoardingPassRepository extends JdbcRepository<BoardingPass, Object[]> {
public BoardingPassRepository() {
this("BOARDING_PASS");
}
public BoardingPassRepository(String tableName) {
super(MAPPER, UNMAPPER, new TableDescription(tableName, null, "flight_no", "seq_no")
);
}
public static final RowMapper<BoardingPass> ROW_MAPPER = //...
public static final RowUnmapper<BoardingPass> UNMAPPER = //...
}

Two things to notice: we extend JdbcRepository<BoardingPass, Object[]> and we provide two ID column names just as expected: "flight_no", "seq_no". We query such DAO by providing both flight_no and seq_no (necessarily in that order) values wrapped by Object[]:

BoardingPass pass = boardingPassRepository.findOne(new Object[] {"FOO-1022", 42});

No doubts, this is cumbersome in practice, so we provide tiny helper method which you can statically import:

import static com.nurkiewicz.jdbcrepository.JdbcRepository.pk;
//...
BoardingPass foundFlight = boardingPassRepository.findOne(pk("FOO-1022", 42));

Check out JdbcRepositoryCompoundPkTest for a working code based on this example.

Transactions

This library is completely orthogonal to transaction management. Every method of each repository requires running transaction and it's up to you to set it up. Typically you would place @Transactional on service layer (calling DAO beans). I don't recommend placing @Transactional over every DAO bean.

Caching

Spring Data JDBC repository library is not providing any caching abstraction or support. However adding @Cacheable layer on top of your DAOs or services using caching abstraction in Spring is quite straightforward. See also: @Cacheable overhead in Spring.

Contributions

..are always welcome. Don't hesitate to submit bug reports and pull requests.

Testing

This library is continuously tested using Travis (). Test suite consists of 60+ distinct tests each run against 8 different databases: MySQL, PostgreSQL, H2, HSQLDB and Derby + MS SQL Server and Oracle tests not run as part of CI.

When filling bug reports or submitting new features please try including supporting test cases. Each pull request is automatically tested on a separate branch.

Building

After forking the official repository building is as simple as running:

$ mvn install

You'll notice plenty of exceptions during JUnit test execution. This is normal. Some of the tests run against MySQL and PostgreSQL available only on Travis CI server. When these database servers are unavailable, whole test is simply skipped:

Results :
Tests run: 484, Failures: 0, Errors: 0, Skipped: 295

Exception stack traces come from root AbstractIntegrationTest.

Design

Library consists of only a handful of classes, highlighted in the diagram below (source):

JdbcRepository is the most important class that implements all PagingAndSortingRepository methods. Each user repository has to extend this class. Also each such repository must at least implement RowMapper and RowUnmapper (only if you want to modify table data).

SQL generation is delegated to SqlGenerator. PostgreSqlGenerator. and DerbySqlGenerator are provided for databases that don't work with standard generator.

Changelog

0.4.1

• Fixed Standalone Configuration and CDI Implementation

0.4

• Repackaged: com.blogspot.nurkiewicz -> com.nurkiewicz

0.3.2

• First version available in Maven central repository
• Upgraded Spring Data Commons 1.6.1 -> 1.8.0

0.3.1

• Upgraded Spring dependencies: 3.2.1 -> 3.2.4 and 1.5.0 -> 1.6.1
• Fixed #5 Allow manually injecting JdbcOperations, SqlGenerator and DataSource

0.3

• Oracle 10g / 11g support (see pull request)
• Upgrading Spring dependency to 3.2.1.RELEASE and Spring Data Commons to 1.5.0.RELEASE (see #4).

0.2

• MS SQL Server 2008/2012 support (see pull request)

0.1

• Initial revision (announcement)

License

This project is released under version 2.0 of the Apache License (same as Spring framework).

现阶段JAVA操作Excel的JAR主要有apache 的POI及jxl.Jxl方便快捷，POI用于对复杂Excel的操作。

Jxl官网：http://www.andykhan.com/jexcelapi/index.html

一、Jxl的API

Jxl的API主要有三个包，jxl,jxl.format,jxl.write。如果单独的分析API，可能对于更明确的了解此API没有太多的帮助，我们还是从Excel文件的层次来剥离此API吧。

一个excel文件由一个工作簿组成，一个工作簿又由n个工作表组成，每个工作表又由多个单元格组成。对应于Jxl中的结构为

       单元格（此处指文本单元格，图像及链接和单元格做为一个层次）分为好多种，所以在API的设计中将Cell作为一个接口而存在。 对应的jxl中的结构为：

而有的时候，我们可能将几个单元格作为一个整体来处理，在API中对应的则是：

    jxl.Range 

    虽然数据是电子表格的核心，但是同时其也需要一些辅助类，比如文件格式设置，工作表设置与显示效果，单元格设置与显示效果等。按照其层次，则依次有以下接口或类。

最后，关于Jxl.format包，此包主要是一些与具体样式有关的接口和枚举，不进行具体描述。
文章摘自：http://blog.csdn.net/surgent/article/details/5836580

myeclipse中的字体看上去比较舒服，但是忽然使用eclipse找不到该字体。具体介绍及解决办法如下：
myeclipse用Courier New这个字体，但是这个字体在Eclipse中默认是选不出来的。到Eclipse preference--->colors and fonts中 找到选择字体的地方（选择字体的下拉菜单中是找不到Courier New的），在左下方有一行蓝色的字“显示更多字体”，点击后会出现一个新的界面，这里会显示你机器上所有的字体。找到Courier New后点击右键选择[显示]，然后关闭这个界面。回到更改字体的界面后你会发现下拉菜单中已经可以选择Courier New这个字体了。然后将该字体默认即可！

人们常说程序员的生活枯燥为人刻板，其实这是你不懂程序员，代码之外，这些高智商的人幽默有趣，论坛常常是他们展现才华的地方，BLOG是他们分享技术的地方，BBS等地方有问题他门总是热心帮助解答，处理程序异常，修改程序错误等。

　　程序员也是很懂得品味人生的，因为工作影响他门也许会对生活感慨，伤感自己没足够或是更多的时间去做工作之外的别的事。陪朋友，亲戚，家人、甚至陪女朋友去买套漂亮的衣服的时间都没有等。但是我个人意见认为，程序员是最诚实、最实用主义及最爱恨分明的，平日工作虽然单调但不乏味。

　　程序员是最诚实从何谈起？

　　程序员在学习和工作期间几乎天天和机器打交道，压根就没有受欺负或是欺负别人的机会，勤奋的程序员在调试无穷多的程序BUG时，已经深深地接受了“诚实”的教育，不诚实的人，他肯定不想做、也做不好程序员。

　　为何说程序员是最实用主义？

　　在10年前我第一次听说电脑，后来初中文化课程中也开设了叫《计算机信息技术》这么一门课程，当时老师不停的在讲台上给我们讲计算机是如何的厉害，但他在我门心里一直只是个神话传说，上一年的计算机课还没曾见过真正的计算机的庐山真面目，只是从老师的口中听说过他是如何的神。从我听说计算机到后来我学习计算机甚至是现在我从事的计算机的工作，已经过去了10个春夏秋冬了，但是目前最先进的计算机也不具备智能，他其实是笨的他也需要人员去操作，当我成为程序员的那刻我意识到计算机的神话是众多程序员的汗水堆积起来的。

       程序员的工作就是把复杂的问题转化为计算机能处理的简单的程序。如果一个问题复杂到连程序员自己都不能理解，他就无法编写程序让更笨的计算机来处理，所以程序信奉“简单----实用”主义。

　　程序员如何的爱恨分明？

　　程序员大都喜欢技术挑战，不喜欢搞测试与维护。高水平的程序员喜欢和高水平的程序员一起工作，我也是这样的一个人，我怕“与臭棋佬下棋，棋越下越臭”。

　　也许是因为工作影响，休闲太少吧，程序员大都不喜欢拉帮结派、耍政治手腕。不信，你数数你认识的程序员，有几个人党派人士？又有几个是政府官员？说到这里我想到了穷人，因为我也是穷人之一。穷人为什么总是穷，很难变为富裕的人呢？因为穷人怕，怕付出没回报，怕投资得不到利益。怕高官怕大人物以至于不赶去和异类人群接触，始终活动在穷人堆里，又怎么会变得富裕呢？出非出现奇迹，麻雀巢里飞出个金凤凰。呵呵，说远了。

　　何解工作单调却不乏味？

　　程序设计的真正含义是什么？

　　要塑造一个程序员又需要多少时间和经历呢？又有那些过程呢？学习过程的天空是黑暗的，记得以前在大学的时候，每天起床后的第一件事就是打开电脑，然后洗溯吃饭，接着就是看书写代码这些，饿了又去吃饭然后又面对电脑，当困了的时候就倒下睡觉。醒了又爬起来，很少和朋友家人联系，每天都过着这样的单调的循环生活，但很遗憾的是我和电脑这么的亲密接触到现在还是不能达到人机合一的境界。

　　我记得我曾经说过，我最好的朋友是我的电脑，无论我是高兴还是烦恼，无论我是兴奋还是疲倦，一直陪伴着我的始终是他。但这句话是针对不同的时间到，如果参加工作了，或许工作中的任务、同事之间的友谊、个人生活中的感情等等都将会成为我们的最爱。总的来说是因事而异、因人而异。

　　饿了就吃，困了就睡，只要时机恰当就进行程序设计。生活、学习及工作融为一体，尽管单调却不乏味，还能独享孤独。

     原文连接：http://blog.sina.com.cn/s/blog_883c46a60101a8ez.html

1、程序猿最烦两件事，第一件事是别人要他给自己的代码写文档，第二件呢？是别人的程序没有留下文档。

2、程序猿的读书历程：x 语言入门 —> x 语言应用实践 —> x 语言高阶编程 —> x 语言的科学与艺术 —> 编程之美 —> 编程之道 —> 编程之禅—> 颈椎病康复指南。

3、还没上大学的时候，高三暑假，跑到家那边的图书城想买传说中的C++的书，然后看到一本C#，我一看，嘿，这个++还写得挺艺术的，重叠起来了，于是把C#买了回来……

4、问：程序猿最讨厌康熙的哪个儿子。答：胤禩。因为他是八阿哥（bug）

5、有一天，程序猿们突然发现他们要涨的工资掉到井里啦！大家都很害怕，连忙一个吊着一个，从树上伸到井里去捞工资。正好他们摸到工资的时候，一个老程序员忽然兴奋的大叫：别蠢了，要涨的工资还好好的挂在天上呢！

6、诸葛亮是一个优秀的程序猿，每一个锦囊都是应对不同的case而编写的！但是优秀的程序猿也敌不过更优秀的bug！六出祈山，七进中原，鞠躬尽瘁，死而后已的诸葛亮只因为有一个错误的case-马谡，整个结构就被break了！

7、生活中程序猿的真实写照、一款游戏一包烟，一台电脑一下午。一盒泡面一壶水，一顿能管一整天。

8、程序猿要了3个孩子，分别取名叫Ctrl、Alt 和Delete，如果他们不听话，程序猿就只要同时敲他们一下就会好的…

9、宪法顶个球！中国的法律都是.txt文件，不是.exe文件。 

10、同事说，他在写i++的时候总觉的自己写的是 我艹.........有木有同感？？？？ 

11、程序员，年二十有二，始从文，连考而不中。 遂习武，练武场上发一矢，中鼓吏，逐之出。 改学IT，自撰一函数，用之，堆栈溢出。 

12、《桃花庵--程序员版》写字楼里写字间，写字间中程序员； 程序人员写程序，又将程序换酒钱； 酒醒只在屏前坐，酒醉还来屏下眠； 酒醉酒醒日复日，屏前屏下年复年； 但愿老死电脑间，不愿鞠躬老板前； 奔驰宝马贵者趣，公交自行程序员； 别人笑我太疯癫，我笑自己命太贱； 但见满街漂亮妹，哪个归得程序员； 

13、有一天某程序员去买肉，要了一公斤， 拿到公平电子秤上一称："额。。怎么少了24克。。"

14、检验代码质量的唯一标准 = 代码review时骂的次数 / 代码review时间 。 

15、杀一个程序员不需要用枪，改三次需求就可以了。

16、C++程序员看不起C 程序员， C 程序员看不起java程序员， java程序员看不起C#程序员，C#程序员看不起美工。周末了，美工带着妹子出去约会了，一群SX程序员还在加班。。。 

17、问：如何生成一个随机的字符串？答：让新手退出VIM 。

18、“我给你出个脑筋急转弯，你说达芬奇密码的上面是什么？” “这。。太难了吧。。不知道。。。” “笨！达芬奇密码的上面就是达芬奇帐号啊，那达芬奇密码的下面是什么？”“我。。。这。。。还是不知道。。。”“是达芬奇验证码”。 

19、随机函数可以帮你实现家庭和谐： Talk(){:top word(1)="恩！"; word(2)="好的！";word(3)="然后呢？";word(4)="有道理";i=random(4); say word(i) goto top;} 

20、程序员爱情观：爱情就是死循环，一旦执行就陷进去了；爱上一个人，就是内存泄漏--你永远释放不了；真正爱上一个人的时候，那就是常量限定，永远不会改变；女朋友就是私有变量，只有我这个类才能调用；情人就是指针用的时候一定要注意，要不然就带来巨大的灾难。 

21、女同学们纷纷表示，这年头不找个程序员老公，还真是连节日低价购物权都没了。

22、Delphi象吉普车，什么路上都能开，却在啥路上也开不好；PB就象卡丁车，只能在固定线路上开，到室外就有些不稳；VC象跑车，你开得起却买不起，而且一旦发生故障，想修都找不到毛病在哪；Java象敞棚车，不管刮风下雨还是艳阳高照，都能照开不误；VB就是摩托车，骑的时间越长，你越痛恨它！ 

23、上联MYSQL明月三千里 下联： XHTML.信号他妈烂! 

24、程序员的四大理想：南极有套房，澳大利亚有群羊，全世界电脑死光光，孩儿有个娘。 

25、有一种崩溃叫密码输入有误；有一种惊慌叫做账号异地登陆；有一种感情叫隐身对其可见；有一种误会叫人机离线；有一种失落叫没有访问权限；有一种感情叫站点访问失败；有一种无奈叫bug无法复现。。。

26、黑体的锯齿，宋体的沧桑，崩溃的避头尾集。美工永远纠结于网站程序员的粗犷，就像MAC永远不懂PC的忧伤。。。。

27、程序猿追求MM不成，含泪追问:我在你眼里算什么？！MM答曰:真人版的windows优化大师……极客哥们莫伤心，小戴安慰递纸巾。

28、 据说有一位软件工程师，一位硬件工程师和一位项目经理同坐车参加研讨会。不幸在从盘山公路下山时坏在半路上了。于是两位工程师和一位经理就如何修车的问题展开了讨论。硬件工程师说：“我可以用随身携带的瑞士军刀把车坏的部分拆下来，找出原因，排除故障。” 项目经理说：“根据经营管理学，应该召开会议，根据问题现状写出需求报告，制订计划，编写日程安排，逐步逼近，alpha测试，beta1测试和beta2测试解决问题。” 软件工程说：“咱们还是应该把车推回山顶再开下来，看看问题是否重复发生。” 

29、【高效的程序员】当世界末日还有5分钟就要到来的时候。程序员: 让我们在这最后的时刻作些什么吧！女友: 那好,让我们在做最后一次吧！程序员: 那剩下的4分50秒做什么啊?

30、【开发时间】项目经理: 如果我再给你一个人,那可以什么时候可以完工？程序员: 3个月吧！项目经理: 那给两个呢？程序员: 1个月吧！项目经理: 那100呢？程序员: 1年吧！项目经理: 那10000呢？程序员: 那我将永远无法完成任务。

31、一个程序员对自己的未来很迷茫，于是去问上帝。“万能的上帝呀，请你告诉我，我的未来会怎样？”上帝说：“我的孩子，你去问Lippman，他现在领导的程序员的队伍可能是地球上最大的”。于是他去问Lippman。Lippman说：“程序员的未来就是驾驭程序员”。这个程序员对这个未来不满意，于是他又去问上帝。“万能的上帝呀，请你告诉我，我的未来会怎样？”。上帝说：“我的孩子，你去问Gates，他现在所拥有的财产可能是地球上最多的”。于是他去问Gates。Gates说：“程序员的未来就是榨取程序员”。这个程序员对这个未来不满意，于是他又去问上帝。“万能的上帝呀，请你告诉我，我的未来会怎样？”。上帝说：“我的孩子，你去问侯捷，他写的计算机书的读者可能是地球上最多的”。于是他去问侯捷。侯捷说：“程序员的未来就是诱惑程序员”。这个程序员对这个未来不满意，于是他又去问上帝。“万能的上帝呀，请你告诉我，我的未来会怎样？”。上帝摇摇头：“唉，我的孩子，你还是别当程序员了”。

32、面试官：“熟悉哪种语言”。应聘者：“JAVA”。面试官：“知道什么叫类么”。应聘者：“我这人实在，工作努力，不知道什么叫累”。面试官：“知道什么是包？”。应聘者：“我这人实在   平常不带包 也不用公司准备了”。面试官：“知道什么是接口吗？”。应聘者：“我这个人工作认真。从来不找借口偷懒”。面试官：“知道什么是继承么”。应聘者：“我是孤儿没什么可以继承的”。面试官:“知道什么叫对象么？”。应聘者:“知道，不过我工作努力，上进心强，暂时还没有打算找对象。”。面试官：“知道多态么？”。应聘者：“知道，我很保守的。我认为让心爱的女人为了自已一时的快乐去堕胎是不道德的行为！请问这和C#有什么关系？”。

33、IT工程师=加班狂+程序员+测试工程师+实施工程师+网络工程师+电工+装卸工+搬运工+超人，有同感的转走。

34、 用一句话总结了HTML,CSS,JS的关系。HTML是名词，JS是动词，CSS是形容词和副词。

35、我是个程序猿，一天我坐在路边一边喝水一边苦苦检查bug。这时一个乞丐在我边上坐下了，开始要饭，我觉得可怜，就给了他1块钱，然后接着调试程序。他可能生意不好，就无聊的看看我在干什么，然后过了一会，他幽幽的说，这里少了个分号。。。分号。。。分号。。。

36、女友对程序员说：“紫禁城占得地方好大呀！”程序员：“杀死那个子进程……”

37、从前有个全国管理系统，是孙中山做的设计，老蒋做的实现，结果老毛写了个病毒，趁着日本黑客对系统做攻击的当口，拿到了管理员权限，把原来那批程序员给隔离了。老邓接手以后，重构代码，出了个2.0版，为了开发速度，遗留了一堆BUG没处理。人们纷纷质疑：是不是核心构架太单一，双核会不会好点？

38、一程序员家的水管坏了，他打电话叫来一个水管工修理。 水管工鼓捣了一个小时，终于把管子修好了，他递给程序员一张600元的帐单。 “600元！”程序员愤怒地说：“我当程序员一天都赚不了这么多钱！” “是啊。”水管工平静地说，“我当程序员的时候也是。”

39、十年前，女：“对不起，我不会喜欢你的，你不要再坚持了，就好比让 Linux 和 Windows 同时运行在一台PC机上，可能吗？”男生听后默默走开，十年后，在一次虚拟技术大会上，我听到一名虚拟技术开发程序员给我讲述了这个故事。

40、程序猿问程序媛："为什么要离开我，我做得还不够好吗？" 媛说："别傻了，我们根本就是两个世界里的人，就像在JS里永远都无法调用JAVA类一样，我们之间也是不可能的。" 猿沉默了很久，转身离开了。一个月之后，他在开源社区公布了dwr的完整代码。

41、【程序员被提bug之后的反应】1.怎么可能； 2.在我这是好的，不信你来看看； 3.真是奇怪，刚刚还好好的； 4.肯定是数据问题； 5.你清下缓存试试； 6.重启下电脑试试； 7.你装的什么版本的类库（jdk） 8.这谁写的代码； 9.尼玛怎么还在用360安全 浏览器 ； 10.用户不会像你这么操作的。

42、敲一夜代码，流两行老泪；用三种语言，唯四肢受罪 ； 待五更鸡鸣，遇骤雨初歇；遂登门而去，伫十里长亭；欲望穿泪眼，无如意郎君；借微薄助力，愿寻得佳偶；成比翼双鸟，乃畅想云端；卷情网之内，做爬虫抓取；为连理桂枝,容数据分析；思千里子规，助框广天地； 念茫茫人海，该如何寻觅？

43、早晨一女生抱着一堆书进了阅览室，结果警报响了，大妈让女生看看是哪本书把警报弄响了，那女生把书倒出来，准备一本一本的测。大妈见状急了，把书分成两份，第一份过了一下，响了。又把这一份分成两份接着测，三回就找到了，大妈用鄙视的眼神看着女生，仿佛在说O(n)和O(log2n)都分不清。

44、发现程序员经常熬夜有三个弊端：第一，记忆力越来越差；第二，数数经常会数错；第四，记忆力越来越差。

45、医院回来的程序猿一脸的苦逼样。程序媛：怎么了？程序猿：得了类风湿性关节炎了，我怕会遗传给下一代啊。程序媛：谁说类风湿性关节炎能遗传的？程序猿一脸诧异：类不是继承的吗？

46、知道JAVA程序员和C程序员的差别吗？食堂里，吃完饭就走的是JAVA程序员，吃完饭还要自己 收拾的那就是是C程序员。至于为什么会这样、大家都明白（因为JAVA自带垃圾回收机制、、、C需要手动释放内存）←这就是原因

47、计算机系的男同学追班里一女同学，结果此女总是躲躲闪闪。 男的看没戏，就另找了一个去追，结果这女的不满意了，质问这男的为啥抛弃她。 男的问：“请教一个电脑问题，如果你点击一个程序，总是提示‘没有响应’，怎么办？” 女的说：“马上结束任务。” 男的：“对，我也是这样想的。”

48、一个程序员的吐槽：即要被当做修电脑的，也要被当作做网站的；即要被当作杀毒的，也要被当作盗号的。我要告诉大家，其实我们只是写代码的。

49、如果一个足球界的人“猝死”了，会被怀疑和赌球有关；如果一个官员“猝死”了，会被怀疑和贪腐有关；如果一个农民"猝死"了，会被怀疑和拆迁有关；而如果一个程序员猝死了，那他真的猝死了。

50、老婆是操作系统，一但安装卸载十分麻烦；小秘是桌面，只要你有兴趣可以天天更换；情人是互联网,风光无限花钱不断；小姐是盗版软件，用时记着先杀毒。

51、前台美女三宝：你好，找谁，倒饮料。产品经理三宝：山寨，改版，再推倒。项目经理三宝：进度，流程，做报表。团队经理三宝：团建，开会，评绩效。数据分析师三宝：SQL，Excel，PPT。人事经理三宝：画饼，忽悠，挖墙脚。设计师三宝：修改，重做，飞机稿。程序员三宝：闷骚，加班，修电脑。

52、对于程序员来说、没老婆不悲催。悲催的是、没老婆、控制台还不停的提示你Error:could not find the object

53、假如生活欺骗了你，不要悲伤不要心急。《代码大全》会一直陪伴着你……

54、有时候真觉得有些事情如同char*一般，从开始就注定，无法改变。

55、洛阳亲友如相问，就说我在敲代码。

56、"如果你ctrl+alt+del，蹦出任务管理器，你从上到下扫一眼，所有的进程你都认识，知道他们是干什么的，并且知道关掉有什么后果，而且你还能从CPU和内存占用的数字跳动上清楚的知道电脑现在什么状态，那么你应该没有女朋友"...........你妹啊

57、用IE6的吃方便面都没有调料包，你知道不知道......

58、普通青年用IDE（Visual Studio, Eclipse, XCode）；文艺青年用VIM, Emacs；二逼青年将IDE设置成VIM模式。

59、程序员换IDE相当于搬家，换主力语言相当于改嫁，换操作系统相当于参加FBI证人保护计划…

60、有两个程序员钓鱼，其中一个钓到一条美人鱼，这个美人鱼上半身是美女，下半身是鱼，于是这个程序员 就吧她放了，另一个问他：Why，他回答说：没有API

61、阿里小米皆自主，百度排名最公平；京东全网最低价，当当爱国很理性；用户体验看新浪，网易从来少愤青；豆瓣从来不约炮，人人分享高水平；从不抄袭数腾讯， 开放安全三六零。

62、编程夜当午，手握小滑鼠。谁知编程辛，行行皆“心”苦；头昏不觉晓，使劲揉眼角。夜夜太辛苦，睡眠知多少；

63、热火朝天的办公室，一精壮青年一边啃着馒头，一边看着眼前产品，愁眉紧锁的他陷入了沉思：产品下一步应该怎么走？如何保证代码质量？如何缩短项目时间？如何控制项目成本？一个个难题需要他思索，抉择。此时，传来项目经理的吆喝：“程旭元，先别敲代码了！给我修下电脑……”

64、原来《人月神话》不是本奇幻小说！ 原来《代码大全》不是一堆开源代码！ 原来《鸟哥的Linux私房菜》不是教你做菜！ 原来《边城》不是教你写代码的！ 原来《深入浅出HTML》不是教你How to Make Love

65、文艺程序员写代码追求让别人看懂，普通程序员追求让自己看懂，2B程序员则追求让编译器能看懂；半年后看自己当初写的代码，文艺程序员不知道是自己写的但很容易看懂，普通程序员知道是自己写的但是不太容易看懂，2B程序员埋头看了半天后拍着桌子吼到：“这是哪个SB写的程序！”

66、我真的想让这个世界变得更好，但是他们不给我源代码……

67、【梦醒时分（程序员版）】你说你写了不该写的代码，搞得程序全是bug。你说你定义了不该定义的接口，架构只能重写。你说你走查过了所有代码，找不到正确的地方。你说你感到万分沮丧，甚至开始不打算编程。

68、曾经有很多次机会可以避免bug，将项目按时，保质保量交付给客户，但我没有珍惜，等到世界末日，我才意识到，程序员界最痛苦的事莫过于此。如果玛雅人能给我一次重新选择的机会，让22号的太阳依然升起，我会重新做程序员，用代码改变世界！

69、据一位不愿透露姓名的程序员说，基本上所有客户的所有要求都能总结为下面这样一幅对联，上联：简单易用界面好，下联：稳定高效花钱少，横批：立马就要。

70、某女：你能让微博的人都吵起来，我今晚就跟你走。 某软件工程师：PHP是最好的语言！ 某论坛炸锅了，各种吵架...。某女：服了你了，我们走吧，你想干啥都行。某软件工程师：今天不行，我一定要说服他们，PHP是最好的语言。

71、“我爱你”三个字，讲出来只要三秒钟，解释要三小时，证明却要一辈子。 “bug”三个字母，发现需要三秒，找到需要三小时，debug却要一辈子…...

72、生活不仅只是敲代码，还有...调bug..。

73、本人擅长Ai、Fw、Br、Ae、Pr、Id、Ps等软件的安装与卸载，精通CSS、JavaScript、PHP、C、C++、C#、Java、Ruby、Perl、Lisp、Python、Objective-C、ActionScript等单词的拼写，熟悉Windows、Linux、Mac OS、IOS、Android等系统的开关机，求一份月薪上万的工作！

74、刚在公交车上，一小朋友拿着一本英语书，问她爸爸：xxxxxx for 100 years，这里为什么用for呢？她爸说：你看，100 years时间很长很长，要循环100次才行，当然用for呀！我听到后，恍然大悟！

78、男朋友写代码不理我，于是我悄悄改掉了web.xml的一个配置，他搞了两天都没调通，我告诉了他，结果他要和我分手，我很伤心，但他的朋友告诉我，他没砍死你才说明他真的爱你…” “楼主别tm编了，程序员哪来的女朋友!” “SB，谁告诉你我是女的了。”

79、产品经理被绑，蒙眼，惊问：“想干什么？”，对方不语，鞭笞之，产品经理求饶：“别打，要钱？”，又一鞭，“十万够不？”，又一鞭，“一百万？”，又一鞭。产品经理崩溃：“你们TMD到底要啥？”“要什么？我帮你做项目，写代码的时候也很想知道你TMD到底想要啥！”

80、某男是程序员，每天半夜三更才回家。某女抱怨：“你就不能提早点回家么？” 某男：“好，一定。” 于是下次某男一直写代码到天亮提着油条豆浆才回家。

81、有人说，女程序员再淑女，一旦编程就会暴露自己的身份，习惯性的把前额的头发往上捋，露出大大的额头。因为CPU高速运作时需要良好的散热。

82、两个程序员在聊天：“我昨天碰到个辣妹。我把她带回家，马上就开始如饥似渴地亲吻，她就坐在我的键盘上，然后……” “你家里也有台电脑？啥配置啊？”

83、【如何夸程序员？】通用：你这代码写得真好看。夸C程序员：你这代码不看注释就能懂，写得真好。夸Ruby程序员：我艹，太神奇了，你怎么做到的！夸Perl程序员：这个正则表达式碉堡了。夸Python程序员：Pythonic！夸Java程序员：你写的代码一点都不像Java！

84、昨晚去KTV找小姐。 美女：请问先生需要什么类型的？ 我：学过编程的都给我出来！ 美女：我就是啊！ 我：两个小时，把Bug给找出来，我着急要！ 美女：客官请自重，小女子卖身不卖艺……

85、某程序猿，一直不为女朋友家人所待见。过完年回来，突然宣布说他们准备今年结婚，这让人很是诧异女方家里何以松口了。本着八卦的心态打听之后才知道——程序猿春节前自己搞了个小软件，把女方家的七姑妈、八大姨的春运火车票都给解决了……他真得感谢12306！

86、对于各种凌乱的电脑问题，其他行业的人，以为程序员们什么都会；程序员中的女程序员，以为男程序员什么都会；男程序员中一般程序员，以为技术好的程序员什么都会；技术好的程序员每次都在网上苦苦找答案。。。

87、程序员跟产品经理一起看电视。每个节目看到一半程序员就换台，看到一半就换台，几次之后产品经理终于忍无可忍的咆哮：老子刚看出点意思你就换、刚看出点意思你就换，到底还让不让人看啦？！程序员淡定的盯着电视道：你半路改需求的时候我可没吱过声！

88、菜鸟：“我该怎么学习WEB编程呢？”大牛：“WEB编程就是一个程序员带着两个MM（MSSQL与MYSQL），玩3P（JSP，PHP，ASP），然后学着How to make love(HTML)..”

89、两程序员向同一个MM求爱，MM说"去环游世界后再来找我!"。码农A立即收拾行李出发。码农B绕MM一圈，然后说"hello world!"，立即感动了MM。其实他只是习惯在做任何新事情前先确定hello world能跑通而已。

90、【世界上最没用的几句话】 1、警察：不要跑！ 2、国足：必胜！ 3、老师：同学们不要睡了！ 4、病人：医生，您轻点儿！ 5、父母：孩子，不要闹了 ！6、罪犯：我是冤枉啊！7、女人：不要嘛！8、男人：我发誓！9、程序员：这个不能实现。

原文连接：http://blog.sina.com.cn/s/blog_883c46a60101a8ex.html

1、改变eclipse 中代码字体大小,就是我打进去的java文件的字体大小(colors and fonts)

wiondow--preferences--general--appearance--colors and fonts--java--java editor text font

设置为:Courier New

SELECT column_name(s) 
FROM table_name1
LEFT JOIN
table_name2  
ON 
table_name1.column_name=table_name2.column_name

SELECT  	
had.deptTypeId as deptTypeId
,hdt.typeName as deptTypeName
,had.id as deptID
,had.deptName as deptName
,isnull(sg.siteGoalPoint,0) as siteGoalPoint
,isnull(sg.supGoalPoint,0) as supGoalPoint
from
--单位
(select a.deptTypeId,a.id,a.deptName
  from HD_ACT_DEPT a															 	
  where 1 = 1 																 	
  and deptTypeId = 'null'										 	
) as had																	 	
LEFT JOIN																	 	
--单位类型																	 	
HD_DEPT_TYPE hdt															 	
ON had.deptTypeId = hdt.id												 																				 	
LEFT JOIN																	 	
--任务完成情况统计表															 	
(select a.siteGoalPoint,a.supGoalPoint,a.deptTypeId,a.deptID 	
from cms_sup_submit_goal a													 	
where a.year = '2013'											 	
) as sg																		 	
on had.deptTypeId = sg.deptTypeId and had.id = sg.deptID					    
ORDER BY had.deptTypeId, had.id

  <Directory "T:/workSpace/workespacePhp/">

    Options Indexes FollowSymLinks MultiViews

    AllowOverride all

        Order allow,deny

    Allow from all

</Directory>

配置环境变量： 

添加三个系统变量： 

1、JAVA_HOME: C:\JDK  实际JDK的位置

2、TOMCAT_HOME(或CATALINA_HOME): C:\Tomcat

3、CLASSPATH: %JAVA_HOME%\lib;%TOMCAT_HOME%\lib

4、path(编辑path时多个用";"隔开)：C:\Program Files\Java\jdk1.6.0_16\bin（JDK的bin中）

机器上有CLASSPATH用分号隔开，然后加在后面。

Tomcat的环境变量就配置完毕了，下面检验Tomcat是否能够运行：

在控制台中转到C:\Tomcat\bin这个目录，运行startup，然后回出现一个窗口，连跳一大串东西，最后表示Server已经运行

在浏览器中输入http://localhost:8080，出现欢迎界面，则表示Tomcat没问题了

然后和上面一样，写入你的第一个Servlet

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class HelloWorld extends HttpServlet

{

public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException

{

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><head><title>");

out.println("This is my first Servlet");

out.println("</title></head><body>");

out.println("<h1>Hello,World!</h1>");

out.println("</body></html>");

}

}

然后照样用javac HelloWorld.java来编译这个文件，如果出现无法import javax.servlet.*

那么就是应该把C:\Tomcat\common\lib里面的servlet-api.jar（根据实际来看）文件拷贝到C:\JDK\jre\lib\ext中，再次编译

然后在Tomcat目录里面的C:\Tomcat\webapps\myweb(目录名可任意)里面按如下的文件结构：

myweb\WEB-INF\web.xml

myweb\WEB-INF\classes\HelloWorld.class(把上面生成的HelloWorld.class文件放在这个里面)

Servlet必须使用C:\Tomcat\webapps\myweb\WEB-INF这个目录下面的web.xml文件进行注册，用记事本打开这个web.xml文件，在里面加入

<servlet>

<servlet-name>HelloWorld</servlet-name>

<servlet-class>HelloWorld</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>HelloWorld</servlet-name>

<url-pattern>/HelloWorld</url-pattern>

</servlet-mapping>

这样的结构

<servlet>

<servlet-name>HelloWorld</servlet-name>

<servlet-class>HelloWorld</servlet-class>

</servlet>

表示指定包含的servlet类.

而以下的结构

<servlet-mapping>

<servlet-name>HelloWorld</servlet-name>

<url-pattern>/HelloWorld</url-pattern>

</servlet-mapping>

表示指定HelloServlet应当映射到哪一种URL模式。

在修改web.xml完毕过后，重新启动Server，然后再输入http://localhost:8080/myweb/HelloWorld

public static Map<String,WorkerVO> WORKER_VO_MAP = new HashMap<String,WorkerVO>();

public static Map<String,QuesterVO> QUESTER_VO_MAP = new HashMap<String,QuesterVO>();

public static Map<String, List<QuesterVO>> WORKER_QUESTER_MAP = new HashMap<String, List<QuesterVO>>();

public static Map<String, WorkerOnlineVO> WORKER_USER = new HashMap<String, WorkerOnlineVO>();