java 知识积累

最新推荐文章于 2022-06-18 21:35:32 发布

ITdada

最新推荐文章于 2022-06-18 21:35:32 发布

阅读量1.4k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/ITdada/article/details/8661734

版权

java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

知识积累：
================================================================================
xml主要作用：传输和存储数据

元素的标志名称规范：
1.区分大小写， <P> 和<p>是连个不同的标志
2.不能以数字或"_"开头
3.不能以字符组合xml或XML、Xml等开头
4.不能包含空格
5.名称中间不能包含冒号(:)

<?xml version="1.0" encoding="UTF-8" ?>
<bookstore>
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="CHILDREN">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="WEB">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>
================================================================================

支付：

守信易支付： http：//www.beijing.com.cn
易宝支付：http://yeepay.com

================================================================================
作为一个软件开发者，你的工作内容远远不止写代码。还有一些是你职责范围内的事：
    预估工作周期
    理解你没写过的软件的功能
    把复杂的问题简单化
    把复杂的问题分解成若干个小问题
    调整代码，为迭代预留空间
    发现并修复漏洞
    上述问题与其他成员协作完成
    如果你直接和你的用户交互，还有更多的建议：
    把用户需求翻译成改进计划；
    深入浅出，把复杂的意思用简单的方式向用户传达；
    明晰每一个尚待解决的问题。

但是在这些职责之上，最重要的是在了解目标用户的基础上设定目标。

设定目标的意思是对工作的节奏和流程保持始终的掌控力，保证你的工作可以进行下去。这意味着要做风险预计，并让用户知晓潜在风险，不至于风险降临时措手不及，这就需要设定一系列的规则和流程。

如果方法得当，有没有设定目标在某些情况下可以造成煎熬和享受工作两种截然不同的结果。

作为一个开发者，你就是一个工匠，可以使用任何的工具去创造，不能让别人的期望凌驾于你的创作自由之上。你必须自主把控这个创造的流程。

如果你让用户的意志凌驾于你的创造之上，很可能会有以下结果：

    你的用户会“认为”应该什么时候可以完成工作，那时候你可能只能拿出半成品，无法满足用户预期；
    如果你的工作没有按照用户预期的时间节点走，他们就会觉得沮丧，丧失信心；
    用户的预期会迫使你做一些你自己并不认同的东西。

当然，最理想的情况是用户会尊重你每一次设定的目标，但这种情况可遇不可求。总之无论何时记住：在软件开发的过程中，你才是那个决定什么时候达到什么目标的人。

================================================================================
================================================================================
webservice

异构平台之间的交互（.net、php、pythod、java）
cxf Axis Metro
JAX-WS （java api    web service）

第一步：创建接口
第二步：实现类
第三步：创建服务（确定网上发布的地址）

网上名称：
SEI （Service endpoin interface）
SIB （Service implemention Bean）

访问 http://localhost:8888/ns?wsdl
到运行-cmd-所在的路径

命令码：wsimport -d D:/webservice/01/ -keep -verbose http://localhost:8888/ns?wsdl

-d D:/webservice/01/ ：表示指定的路径
-keep :表示保持java代码原文件和编译过的代码
-verbose：表示显示生成的详细信息过程
http://localhost:8888/ns?wsdl ：表示网络中的 wsdl

http://localhost:8888/ns?wsdl中的wsdl简单解释：
types:用来定义访问的类型
message：SOAP
portType：指明服务器的接口，并且通过相应绑定in和out的消息：其中in表示参数，out表示返回值
bingding：指定传递消息所使用的格式
service：指定服务器所发布的名称

代码优先
契约优先

SOA
============================================================
xml：两种方式解释 DTD和schema

schema出现的目的是通过一个更加合理的方式来编写xml的限制文件（基于xml语法的方式）
schema可以使用命名空间来支持多个名称相同的元素（防止命名空间重复）
schema可以很好的完成对java或者所有对象的修饰并且提供了大量的数据类型

DTD

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE persons [
   <!ELEMENT persons (person+)>
   <!ELEMENT person (name,password?,age)>

   <!ATTLIST person sex CDATA #REQUIRED>
   <!ATTLIST person id ID #REQUIRED>
   <!ELEMENT name (#PCDATA)>
   <!ELEMENT password (#PCDATA)>
   <!ELEMENT age (#PCDATA)>
]>
<persons>
   <person id="p1" sex="男">
       <name>zhangsan</name>
       <password>123123</password>
       <age>12</age>
   </person>
   <person id="p2" sex="女">
       <name></name>
       <password></password>
       <age></age>
   </person>
</persons>
=========================================================================
classroom.dtd 文件

<?xml version="1.0" encoding="UTF-8"?>

<!ELEMENT classroom (claName,grade,students)>
<!ATTLIST classroom id ID #REQUIRED>
<!ELEMENT claName (#PCDATA)>
<!ELEMENT grade (#PCDATA)>
<!ELEMENT students (student+)>
<!ELEMENT student (id,stuName,age)>
<!ELEMENT id (#PCDATA)>
<!ELEMENT stuName (#PCDATA)>
<!ELEMENT

classroom.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE classroom SYSTEM "classroom.dtd">
<classroom id="c1">
   <claName>10计算机应用技术</claName>
   <grade>2010</grade>
   <students>
       <student>
           <id>1</id>
           <stuName>zhangsan</stuName>
           <age>12</age>
       </student>
       <student>
           <id>2</id>
           <stuName>lisi</stuName>
           <age>122</age>
       </student>
   </students>
</classroom>

==========================================
schema 文件

user.xsd

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
       targetNamespace="http://www.example.org/01"
       xmlns:tns="http://www.example.org/01"
       elementFormDefault="qualified">

             <element name="user">
               <complexType>
                   <sequence>
                       <element name="id" type="int"/>
                       <element name="username" type="string"/>
                       <element name="born" type="date"/>
                   </sequence>
               </complexType>
           </element>

</schema>

user.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<user xmlns="http://www.example.org/01"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="user.xsd">引入
      

      <id>1</id>
      <username>zhangshan</username>
      <born>1999-12-1</born>
</user>

1.xmlns="http://www.w3.org/2001/XMLSchema"

schema 的默认命名空间，不能修改,但是可以增加前缀，如果增加前缀之后就意味着创建所有element等元素都需要增加前缀。

2.targetNamespace="http://www.example.org/01"

自己这个文档的命名空间，可以方便其他xml或者schema文件引用

3.xmlns:tns="http://www.example.org/01"
此处的名称和自己的名称空间的名称一致，但是增加了tns的前缀，此时如果要引用当前文件所创建的类型，需要加上tns的前缀

07_schema的元素和属性的定义

总结：写.xsd 文件
一个schema就是一个类，这个类里面只有一个element，然后公开多个complexType，假设年级里面有学生，可以导入那张student.sxd文件进来
<xsd:include schemaLocation="student.xsd"/>
前提是：命名空间必须是同一个classroom
targetNamespace="http://www.example.org/classroom"

将.sxd文件转编译成java文件：步骤

程序 -运行 -cd到文件目录
命令：xjc -d d:/webservice/02 -verbose classroom.xsd

SOAP 是基于 XML 的简易协议，可使应用程序在 HTTP 之上进行信息交换。

或者更简单地说：SOAP 是用于访问网络服务的协议。

==================================================================================
DWR

1步：先引入文件engine 和util .js文件

<script type='text/javascript' src='<%=basePath%>/dwr/engine.js'></script>
<script type='text/javascript' src='<%=basePath%>/dwr/util.js'></script>
<script type='text/javascript' src='<%=basePath>/dwr/interface/AddUserInfoAjax.js'></script>

2步：在页面写javascript 需要的方法

3步：配置在dwr.xml文件，将那个转换的类型 javascript 名称写入，注入要转换的类名。

<create creator="spring" javascript="AddCustomerInfoAjax">
   <param name="beanName" value="addCustomerInfoAjaxAction"/>

</create>

4步：在dwr.xml文件的配置，将javascript="AddCustomerInfoAjax"引入到jsp页面

5步：在页面写javascript 需要的方法，里面调用java的方法

==================================================================================

(1)导入excel文件==========================
1步：构造一个可写的工作簿

//1.构建Workbook
Workbook rwb = Workbook.getWorkbook(excelFile);
//2.获得工作表
Sheet rs = rwb.getSheet(0);
List<ContactPersonInfo> contactPersonInfoList=new ArrayList<ContactPersonInfo>();
for(int i=1;i<rs.getRows();i++){

//3.将需要的字段插入表格表中
Cell fcell=rs.getCell(0,i);
if(fcell.getType()==CellType.NUMBER){
NumberCell nc=(NumberCell) fcell;//转换类型
int contactId=(int) nc.getValue();//获取的值
contactPersonInfo.setContactId(contactId);//将值插入到集合里去
// System.out.println(contactId);
}

//4. 写入文件
rwb.close();

(2)导出excel文件 =======================================
//1.创建文件.xls文件
File file=new File("contactpersoninfo.xls");

//2.文件输出流
OutputStream os = new FileOutputStream(file);
//3.创建工作表
WritableWorkbook wwb=Workbook.createWorkbook(os);
//创建工作表
WritableSheet ws=wwb.createSheet("contactpersoninfo", 0);

//Label 4.创建工作表里面的字段并添加

Label label1=new Label(0,0,"编号");
Label label2=new Label(1,0,"客户名称");
Label label3=new Label(2,0,"联系人姓名");
ws.addCell(label1);
ws.addCell(label2);
ws.addCell(label3);
//5.循环内容
for(int i=0;i<contactPersonInfos.size();i++){
ContactPersonInfo contactPerson=contactPersonInfos.get(i);
Number complainId=new Number(0,i+1,contactPerson.getContactId());
Label customerName=new Label(1,i+1,contactPerson.getCustomerInfo().getCustomerName());
}
6.添加进去
ws.addCell(complainId);
ws.addCell(customerName);

7.写入
wwb.write();
8.关闭
wwb.close();
=========================================================================================================
总结不同：
mysql 插入字段数据是可以连写的
oracle 插入字段数据是不可以连写的

=========================================================================================================

Velocity是一个基于java的模板引擎（template engine）

<一>下载路径:http://velocity.apache.org/

velocity-1.6-dep.jar
\lib\log4j-1.2.12.jar

如果不使用velocity-1.6-dep.jar，也可以使用velocity-1.6.jar，但这时需要把\lib下的commons-collections-3.2.1.jar\commons-lang-2.4.jar和oro-2.0.8.jar放入类路径下。 velocity-1.6-dep.jar文件内部已经包含前面三个jar文件的类。

<二>使用Velocity的配置

在类路径下加入velocity.properties，

内容如下：指定日志文件存放位置
runtime.log = E:\\spring\\velocity\\velocity_example.log

指定模版文件加载位置
file.resource.loader.path=E:\\spring\\velocity

指定输入编码格式
input.encoding=UTF-8

指定velocity的servlet向浏览器输出内容的编码
default.contentType=text/html; charset\=UTF-8

指定输出编码格式
output.encoding=UTF-8

====================================================================================

http://www.jb51.net/article/30866.htm

http://wenku.baidu.com/view/51cd525777232f60ddcca1ae.html

================================================================================

    声明实体Bean

    @Entity
    public class Flight implements Serializable {
      Long id;
      @Id
      public Long getId() { return id; }
      public void setId(Long id) { this.id = id; }
    }

    @Entity 注解将一个类声明为实体 Bean, @Id 注解声明了该实体Bean的标识属性。

    Hibernate 可以对类的属性或者方法进行注解。属性对应field类别，方法的 getXxx()对应property类别。

    定义表

    通过 @Table 为实体Bean指定对应数据库表，目录和schema的名字。

    @Entity
    @Table(name="tbl_sky")
    public class Sky implements Serializable {

    ...

    @Table 注解包含一个schema和一个catelog 属性，使用@UniqueConstraints 可以定义表的唯一约束。

    @Table(name="tbl_sky",
      uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})}
    )

    上述代码在 "month" 和 "day" 两个 field 上加上 unique constrainst.

    @Version 注解用于支持乐观锁版本控制。

    @Entity
    public class Flight implements Serializable {
       ...
       @Version
       @Column(name="OPTLOCK")
       public Integer getVersion() { ... }
    }

    version属性映射到 "OPTLOCK" 列，entity manager 使用这个字段来检测冲突。一般可以用数字或者 timestamp 类型来支持 version.

    实体Bean中所有非static 非 transient 属性都可以被持久化，除非用@Transient注解。

    默认情况下，所有属性都用 @Basic 注解。

    public transient int counter; //transient property

    private String firstname; //persistent property
    @Transient
    String getLengthInMeter() { ... } //transient property
    String getName() {... } // persistent property
    @Basic
    int getLength() { ... } // persistent property
    @Basic(fetch = FetchType.LAZY)
    String getDetailedComment() { ... } // persistent property
    @Temporal(TemporalType.TIME)
    java.util.Date getDepartureTime() { ... } // persistent property
    @Enumerated(EnumType.STRING)
    Starred getNote() { ... } //enum persisted as String in database

    上述代码中 counter, lengthInMeter 属性将忽略不被持久化，而 firstname, name, length 被定义为可持久化和可获取的。

    @TemporalType.(DATE,TIME,TIMESTAMP) 分别Map java.sql.(Date, Time, Timestamp).

    @Lob 注解属性将被持久化为 Blog 或 Clob 类型。具体的java.sql.Clob, Character[], char[] 和 java.lang.String 将被持久化为 Clob 类型. java.sql.Blob, Byte[], byte[] 和 serializable type 将被持久化为 Blob 类型。

    @Lob
    public String getFullText() {
       return fullText; // clob type
    }


    @Lob
    public byte[] getFullCode() {
      return fullCode; // blog type
    }

    @Column 注解将属性映射到列。

    @Entity
    public class Flight implements Serializable {
       ...
       @Column(updatable = false, name = "flight_name", nullable = false, length=50)
       public String getName() { ... }

    定义 name 属性映射到 flight_name column, not null, can't update, length equal 50

    @Column(
       name="columnName"; (1) 列名
       boolean unique() default false; (2)    是否在该列上设置唯一约束
       boolean nullable() default true; (3)   列可空？
       boolean insertable() default true; (4) 该列是否作为生成 insert语句的一个列
       boolean updatable() default true; (5) 该列是否作为生成 update语句的一个列
       String columnDefinition() default ""; (6) 默认值
       String table() default ""; (7)             定义对应的表（deault 是主表）
       int length() default 255; (8)              列长度
       int precision() default 0; // decimal precision (9) decimal精度
       int scale() default 0; // decimal scale        (10) decimal长度

    嵌入式对象（又称组件）也就是别的对象定义的属性

    组件类必须在类一级定义 @Embeddable 注解。在特定的实体关联属性上使用 @Embeddable 和 @AttributeOverride 注解可以覆盖该属性对应的嵌入式对象的列映射。

    @Entity
    public class Person implements Serializable {
       // Persistent component using defaults
       Address homeAddress;
       @Embedded
       @AttributeOverrides( {
          @AttributeOverride(name="iso2", column = @Column(name="bornIso2") ),
          @AttributeOverride(name="name", column = @Column(name="bornCountryName") )
       } )
       Country bornIn;
       ...
    }

    @Embeddable
    public class Address implements Serializable {
       String city;
       Country nationality; //no overriding here
    }

    @Embeddable
    public class Country implements Serializable {
       private String iso2;
       @Column(name="countryName") private String name;
       public String getIso2() { return iso2; }
       public void setIso2(String iso2) { this.iso2 = iso2; }
       public String getName() { return name; }
       public void setName(String name) { this.name = name; }
       ...
    }

    Person 类定义了 Address 和 Country 对象，具体两个类实现见上。

    无注解属性默认值：

    ? 属性为简单类型，则映射为 @Basic

    ? 属性对应的类型定义了 @Embeddable 注解，则映射为 @Embedded

    ? 属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。

    ? 属性的类型为 java.sql.Clob or java.sql.Blob, 则映射到 @Lob 对应的类型。

    映射主键属性

    @Id 注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。

    ? AUTO - 可以是 identity column, sequence 或者 table 类型，取决于不同底层的数据库
    ? TABLE - 使用table保存id值
    ? IDENTITY - identity column
    ? SEQUENCE - seque

    nce

    @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
    public Integer getId() { ... }

    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    public Long getId() { ... }

    AUTO 生成器，适用与可移值的应用，多个@Id可以共享同一个 identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator 和 @TableGenerator 可以配置不同的 identifier 生成器。

    <table-generator name="EMP_GEN"
         table="GENERATOR_TABLE"
         pk-column-name="key"
         value-column-name="hi"
         pk-column-value="EMP"
         allocation-size="20"/>
    //and the annotation equivalent
    @javax.persistence.TableGenerator(
         name="EMP_GEN",
         table="GENERATOR_TABLE",
         pkColumnName = "key",
         valueColumnName = "hi"
         pkColumnValue="EMP",
         allocationSize=20
    )
    <sequence-generator name="SEQ_GEN"
         sequence-name="my_sequence"
         allocation-size="20"/>
    //and the annotation equivalent
    @javax.persistence.SequenceGenerator(
         name="SEQ_GEN",
         sequenceName="my_sequence",
         allocationSize=20
    )

    The next example shows the definition of a sequence generator in a class scope:

    @Entity
    @javax.persistence.SequenceGenerator(
        name="SEQ_STORE",
        sequenceName="my_sequence"
    )
    public class Store implements Serializable {
       private Long id;
       @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
       public Long getId() { return id; }
    }

    Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。

    通过下面语法，你可以定义组合键。

    ? 将组件类注解为 @Embeddable，并将组件的属性注解为 @Id
    ? 将组件的属性注解为 @EmbeddedId
    ? 将类注解为 @IdClass，并将该实体中所有主键的属性都注解为 @Id

    @Entity
    @IdClass(FootballerPk.class)
    public class Footballer {
      //part of the id key
      @Id public String getFirstname() {
        return firstname;
      }
      public void setFirstname(String firstname) {
         this.firstname = firstname;
      }
      //part of the id key
      @Id public String getLastname() {
        return lastname;
      }
      public void setLastname(String lastname) {
        this.lastname = lastname;
      }
      public String getClub() {
        return club;
      }
      public void setClub(String club) {
       this.club = club;
      }
      //appropriate equals() and hashCode() implementation
    }

    @Embeddable
    public class FootballerPk implements Serializable {
      //same name and type as in Footballer
      public String getFirstname() {
        return firstname;
      }
      public void setFirstname(String firstname) {
        this.firstname = firstname;
      }
      //same name and type as in Footballer
      public String getLastname() {
        return lastname;
      }
      public void setLastname(String lastname) {
       this.lastname = lastname;
      }
      //appropriate equals() and hashCode() implementation
    }

    @Entity
    @AssociationOverride( name="id.channel", joinColumns = @JoinColumn(name="chan_id") )
    public class TvMagazin {
       @EmbeddedId public TvMagazinPk id;
       @Temporal(TemporalType.TIME) Date time;
    }


    @Embeddable
    public class TvMagazinPk implements Serializable {
       @ManyToOne
       public Channel channel;
       public String name;
       @ManyToOne
       public Presenter presenter;
    }

    映射继承关系

    EJB支持3种类型的继承。

    ? Table per Class Strategy: the <union-class> element in Hibernate 每个类一张表
    ? Single Table per Class Hierarchy Strategy: the <subclass> element in Hibernate 每个类层次结构一张表
    ? Joined Subclass Strategy: the <joined-subclass> element in Hibernate 连接的子类策略

    @Inheritance 注解来定义所选的之类策略。

    每个类一张表

    @Entity
    @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
    public class Flight implements Serializable {

    有缺点，如多态查询或关联。Hibernate 使用 SQL Union 查询来实现这种策略。这种策略支持双向的一对多关联，但不支持 IDENTIFY 生成器策略，因为ID必须在多个表间共享。一旦使用就不能使用AUTO和IDENTIFY生成器。

    每个类层次结构一张表

    @Entity
    @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
    @DiscriminatorColumn(
        name="planetype",
        discriminatorType=DiscriminatorType.STRING
    )
    @DiscriminatorValue("Plane")
    public class Plane { ... }

    @Entity
    @DiscriminatorValue("A320")
    public class A320 extends Plane { ... }

    整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。

    Plane 是父类。@DiscriminatorColumn 注解定义了辨别符列。对于继承层次结构中的每个类, @DiscriminatorValue 注解指定了用来辨别该类的值。辨别符列名字默认为 DTYPE，其默认值为实体名。其类型为DiscriminatorType.STRING。

    连接的子类

    @Entity
    @Inheritance(strategy=InheritanceType.JOINED)
    public class Boat implements Serializable { ... }


    @Entity
    public class Ferry extends Boat { ... }

    @Entity
    @PrimaryKeyJoinColumn(name="BOAT_ID")
    public class AmericaCupClass extends Boat { ... }

    以上所有实体使用 JOINED 策略 Ferry和Boat class使用同名的主键关联(eg: Boat.id = Ferry.id)， AmericaCupClass 和 Boat 关联的条件为 Boat.id = AmericaCupClass.BOAT_ID.

    从父类继承的属性

    @MappedSuperclass
    public class BaseEntity {
      @Basic
      @Temporal(TemporalType.TIMESTAMP)
      public Date getLastUpdate() { ... }
      public String getLastUpdater() { ... }
      ...
    }


    @Entity class Order extends BaseEntity {
      @Id public Integer getId() { ... }
      ...
    }

    继承父类的一些属性，但不用父类作为映射实体，这时候需要 @MappedSuperclass 注解。上述实体映射到数据库中的时候对应 Order 实体Bean, 其具有 id, lastUpdate, lastUpdater 三个属性。如果没有@MappedSuperclass 注解,则父类中属性忽略，这是 Order 实体 Bean 只有 id 一个属性。

    映射实体Bean的关联关系

    一对一

    使用 @OneToOne 注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。

    ? 关联的实体都共享同样的主键。

    @Entity
    public class Body {
      @Id
      public Long getId() { return id; }
      @OneToOne(cascade = CascadeType.ALL)
      @PrimaryKeyJoinColumn
      public Heart getHeart() {
         return heart;
      }
      ...
    }

    @Entity
    public class Heart {
      @Id
      public Long getId() { ...}
    }

    通过@PrimaryKeyJoinColumn 注解定义了一对一的关联关系。


    多对一

    使用 @ManyToOne 注解定义多对一关系。

    @Entity()
    public class Flight implements Serializable {
      @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
      @JoinColumn(name="COMP_ID")
      public Company getCompany() {
        return company;
      }
      ...
    }

    其中@JoinColumn 注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。本例中为company_id,因为关联的属性是company, Company的主键为 id.

    @ManyToOne 注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要 targetEntity 定义（使用接口作为返回值，而不是常用的实体）。

    @Entity()
    public class Flight implements Serializable {
       @ManyToOne(cascade=   {CascadeType.PERSIST,CascadeType.MERGE},targetEntity= CompanyImpl.class)
       @JoinColumn(name="COMP_ID")
       public Company getCompany() {
         return company;
       }
       ...
    }


    public interface Company {
       ...

    多对一也可以通过关联表的方式来映射，通过 @JoinTable 注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过@JoinTable.inverseJoinColumns）.

    @Entity()
    public class Flight implements Serializable {

       @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
       @JoinTable(name="Flight_Company",
           joinColumns = @JoinColumn(name="FLIGHT_ID"),
           inverseJoinColumns = @JoinColumn(name="COMP_ID")
       )
       public Company getCompany() {
           return company;
       }
       ...
    }

    集合类型



     一对多

    @OneToMany 注解可定义一对多关联。一对多关联可以是双向的。

    双向

    规范中多对一端几乎总是双向关联中的主体（owner）端，而一对多的关联注解为 @OneToMany(mappedBy=)

    @Entity
    public class Troop {
      @OneToMany(mappedBy="troop")
      public Set<Soldier> getSoldiers() {
      ...
    }


    @Entity
    public class Soldier {
      @ManyToOne
      @JoinColumn(name="troop_fk")
      public Troop getTroop() {
      ...
      }

    Troop 通过troop属性和Soldier建立了一对多的双向关联。在 mappedBy 端不必也不能定义任何物理映射。

    单向

    @Entity
    public class Customer implements Serializable {
       @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
       @JoinColumn(name="CUST_ID")
       public Set<Ticket> getTickets() {
          ...
       }

    @Entity
    public class Ticket implements Serializable {
       ... //no bidir
    }

    一般通过连接表来实现这种关联，可以通过@JoinColumn注解来描述这种单向关联关系。上例 Customer 通过 CUST_ID 列和 Ticket 建立了单向关联关系。

    通过关联表来处理单向关联

    @Entity
    public class Trainer {
      @OneToMany
      @JoinTable(
         name="TrainedMonkeys",
         joinColumns = @JoinColumn( name="trainer_id"),
         inverseJoinColumns = @JoinColumn( name="monkey_id")
      )
      public Set<Monkey> getTrainedMonkeys() {
         ...
      }


    @Entity
    public class Monkey {
      ... //no bidir
    }

    通过关联表来处理单向一对多关系是首选，这种关联通过 @JoinTable 注解来进行描述。上例子中 Trainer 通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns).

    默认处理机制

    通过连接表来建立单向一对多关联不需要描述任何物理映射，表名由一下3个部分组成，主表(owner table)表名 + 下划线 + 从表(the other side table)表名。指向主表的外键名:主表表名+下划线+主表主键列名指向从表的外键定义为唯一约束，用来表示一对多的关联关系。

    @Entity
    public class Trainer {
      @OneToMany
      public Set<Tiger> getTrainedTigers() {
      ...
    }


    @Entity
    public class Tiger {
      ... //no bidir
    }

    上述例子中 Trainer 和 Tiger 通过 Trainer_Tiger 连接表建立单向关联关系。其中外键 trainer_id 关联到 Trainer表，而外键 trainedTigers_id 关联到 Tiger 表。

    多对多

    通过 @ManyToMany 注解定义多对多关系，同时通过 @JoinTable 注解描述关联表和关联条件。其中一端定义为 owner, 另一段定义为 inverse(对关联表进行更新操作，这段被忽略)。

    @Entity
    public class Employer implements Serializable {
      @ManyToMany(
        targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,
        cascade={CascadeType.PERSIST, CascadeType.MERGE}
      )
      @JoinTable(
        name="EMPLOYER_EMPLOYEE",
        joinColumns=@JoinColumn(name="EMPER_ID"),
        inverseJoinColumns=@JoinColumn(name="EMPEE_ID")
      )
      public Collection getEmployees() {
        return employees;
      }
      ...
    }

    @Entity
    public class Employee implements Serializable {
      @ManyToMany(
        cascade = {CascadeType.PERSIST, CascadeType.MERGE},
        mappedBy = "employees",
        targetEntity = Employer.class
      )
      public Collection getEmployers() {
        return employers;
      }
    }

    默认值：

    关联表名：主表表名 + 下划线 + 从表表名；关联表到主表的外键：主表表名 + 下划线 + 主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名 + 下划线 + 从表的主键列名。

    用 cascading 实现传播持久化（Transitive persistence）

    cascade 属性接受值为 CascadeType 数组，其类型如下：

    ? CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体是受管状态，或者当 persist() 函数被调用时，触发级联创建(create)操作。


    ? CascadeType.MERGE: cascades the merge operation to associated entities if merge() is called or if the entity is managed 如果一个实体是受管状态，或者当 merge() 函数被调用时，触发级联合并(merge)操作。


    ? CascadeType.REMOVE: cascades the remove operation to associated entities if delete() is called 当 delete() 函数被调用时，触发级联删除(remove)操作。


    ? CascadeType.REFRESH: cascades the refresh operation to associated entities if refresh() is called 当 refresh() 函数被调用时，出发级联更新(refresh)操作。


    ? CascadeType.ALL: all of the above 以上全部

    映射二级列表

    使用类一级的 @SecondaryTable 和 @SecondaryTables 注解可以实现单个实体到多个表的映射。使用 @Column 或者 @JoinColumn 注解中的 table 参数可以指定某个列所属的特定表。

    @Entity
    @Table(name="MainCat")
    @SecondaryTables({
        @SecondaryTable(name="Cat1", pkJoinColumns={
               @PrimaryKeyJoinColumn(name="cat_id", referencedColumnName="id")}),
        @SecondaryTable(name="Cat2", uniqueConstraints={
               @UniqueConstraint(columnNames={"storyPart2"})})
     })
    public class Cat implements Serializable {
      private Integer id;
      private String name;

      private String storyPart1;
      private String storyPart2;
      @Id @GeneratedValue
      public Integer getId() {
        return id;
      }
      public String getName() {
        return name;
      }
      @Column(table="Cat1")
      public String getStoryPart1() {
        return storyPart1;
      }
      @Column(table="Cat2")
      public String getStoryPart2() {
        return storyPart2;
      }

    上述例子中， name 保存在 MainCat 表中，storyPart1保存在 Cat1 表中，storyPart2 保存在 Cat2 表中。 Cat1 表通过外键 cat_id 和 MainCat 表关联， Cat2 表通过 id 列和 MainCat 表关联。对storyPart2 列还定义了唯一约束。

    映射查询

    使用注解可以映射 EJBQL/HQL 查询，@NamedQuery 和 @NamedQueries 是可以使用在类级别或者JPA的XML文件中的注解。

    <entity-mappings>
     <named-query name="plane.getAll">
      <query>select p from Plane p</query>
     </named-query>
     ...
    </entity-mappings>
    ...
    @Entity
    @NamedQuery(name="night.moreRecentThan", query="select n from Night n where n.date >= :date")
    public class Night {
     ...
    }
    public class MyDao {
     doStuff() {
       Query q = s.getNamedQuery("night.moreRecentThan");
       q.setDate( "date", aMonthAgo );
       List results = q.list();
       ...
     }
     ...
    }

    可以通过定义 QueryHint 数组的 hints 属性为查询提供一些 hint 信息。下图是一些 Hibernate hints:



    映射本地化查询

    通过@SqlResultSetMapping 注解来描述 SQL 的 resultset 结构。如果定义多个结果集映射，则用 @SqlResultSetMappings。

    @NamedNativeQuery(name="night&area", query="select night.id nid, night.night_duration, "
         + " night.night_date, area.id aid, night.area_id, area.name "
         + "from Night night, Area area where night.area_id = area.id", resultSetMapping="joinMapping")

    @SqlResultSetMapping( name="joinMapping", entities={
      @EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class, fields = {
       @FieldResult(name="id", column="nid"),
       @FieldResult(name="duration", column="night_duration"),
       @FieldResult(name="date", column="night_date"),
       @FieldResult(name="area", column="area_id"),
       discriminatorColumn="disc"
      }),

      @EntityResult(entityClass=org.hibernate.test.annotations.query.Area.class, fields = {
       @FieldResult(name="id", column="aid"),
       @FieldResult(name="name", column="name")
      })
     }
    )

    上面的例子，名为“night&area”的查询和 "joinMapping"结果集映射对应，该映射返回两个实体，分别为 Night 和 Area, 其中每个属性都和一个列关联，列名通过查询获取。

    @Entity
    @SqlResultSetMapping(name="implicit",
      entities=@EntityResult(
        entityClass=org.hibernate.test.annotations.@NamedNativeQuery(
          name="implicitSample", query="select * from SpaceShip",
          resultSetMapping="implicit")
    public class SpaceShip {
     private String name;
     private String model;
     private double speed;
     @Id
     public String getName() {
      return name;
     }
     public void setName(String name) {
      this.name = name;
     }
     @Column(name="model_txt")
     public String getModel() {
      return model;
     }
     public void setModel(String model) {
      this.model = model;
     }
     public double getSpeed() {
      return speed;
     }
     public void setSpeed(double speed) {
      this.speed = speed;
     }
    }

    上例中 model1 属性绑定到 model_txt 列，如果和相关实体关联设计到组合主键，那么应该使用 @FieldResult 注解来定义每个外键列。@FieldResult的名字组成：定义这种关系的属性名字 + "." + 主键名或主键列或主键属性。

    @Entity
    @SqlResultSetMapping(name="compositekey",
     entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class,
      fields = {
       @FieldResult(name="name", column = "name"),
       @FieldResult(name="model", column = "model"),
       @FieldResult(name="speed", column = "speed"),
       @FieldResult(name="captain.firstname", column = "firstn"),
       @FieldResult(name="captain.lastname", column = "lastn"),
       @FieldResult(name="dimensions.length", column = "length"),
       @FieldResult(name="dimensions.width", column = "width")
      }),
     columns = { @ColumnResult(name = "surface"),

    @ColumnResult(name = "volume") } )
     @NamedNativeQuery(name="compositekey",
     query="select name, model, speed, lname as lastn, fname as firstn, length, width, length * width as resultSetMapping="compositekey")
    })

    如果查询返回的是单个实体，或者打算用系统默认的映射，这种情况下可以不使用 resultSetMapping，而使用resultClass属性，例如：

    @NamedNativeQuery(name="implicitSample", query="select * from SpaceShip",
                                                resultClass=SpaceShip.class)
    public class SpaceShip {

    Hibernate 独有的注解扩展

    Hibernate 提供了与其自身特性想吻合的注解，org.hibernate.annotations package包含了这些注解。

    实体

    org.hibernate.annotations.Entity 定义了 Hibernate 实体需要的信息。

    ? mutable: whether this entity is mutable or not 此实体是否可变


    ? dynamicInsert: allow dynamic SQL for inserts   用动态SQL新增


    ? dynamicUpdate: allow dynamic SQL for updates   用动态SQL更新


    ? selectBeforeUpdate: Specifies that Hibernate should never perform an SQL UPDATE unless it is certain that an object is actually modified.指明Hibernate从不运行SQL Update，除非能确定对象已经被修改


    ? polymorphism: whether the entity polymorphism is of PolymorphismType.IMPLICIT (default) or PolymorphismType.EXPLICIT 指出实体多态是 PolymorphismType.IMPLICIT(默认)还是PolymorphismType.EXPLICIT


    ? optimisticLock: optimistic locking strategy (OptimisticLockType.VERSION, OptimisticLockType.NONE, OptimisticLockType.DIRTY or OptimisticLockType.ALL) 乐观锁策略

    标识符

    @org.hibernate.annotations.GenericGenerator和@org.hibernate.annotations.GenericGenerators允许你定义hibernate特有的标识符。

    @Id @GeneratedValue(generator="system-uuid")
    @GenericGenerator(name="system-uuid", strategy = "uuid")
    public String getId() {
    @Id @GeneratedValue(generator="hibseq")
    @GenericGenerator(name="hibseq", strategy = "seqhilo",
       parameters = {
         @Parameter(name="max_lo", value = "5"),
         @Parameter(name="sequence", value="heybabyhey")
       }
    )
    public Integer getId() {

    新例子

    @GenericGenerators(
     {
      @GenericGenerator(
       name="hibseq",
       strategy = "seqhilo",
       parameters = {
        @Parameter(name="max_lo", value = "5"),
        @Parameter(name="sequence", value="heybabyhey")
       }
      ),
      @GenericGenerator(...)
     }
    )

    自然ID

    用 @NaturalId 注解标识

    公式

    让数据库而不是JVM进行计算。

    @Formula("obj_length * obj_height * obj_width")
    public long getObjectVolume()

    索引

    通过在列属性(property)上使用@Index注解，可以指定特定列的索引，columnNames属性(attribute)将随之被忽略。

    @Column(secondaryTable="Cat1")
    @Index(name="story1index")
    public String getStoryPart1() {
      return storyPart1;
    }

    辨别符

    @Entity
    @DiscriminatorFormula("case when forest_type is null then 0 else forest_type end")
    public class Forest { ... }

    过滤查询 ...





    ? 其中一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。

    @Entity
    public class Customer implements Serializable {
       @OneToOne(cascade = CascadeType.ALL)
       @JoinColumn(name="passport_fk")
       public Passport getPassport() {
       ...
    }


    @Entity
    public class Passport implements Serializable {
       @OneToOne(mappedBy = "passport")
       public Customer getOwner() {
       ...
    }

    通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解，则系统自动处理，在主表中将创建连接列，列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。上例为 passport_id, 因为Customer 中关联属性为 passport, Passport 的主键为 id.


    ? 通过关联表来保存两个实体之间的关联关系。注：一对一，则关联表每个外键都必须是唯一约束。

    @Entity
    public class Customer implements Serializable {
       @OneToOne(cascade = CascadeType.ALL)
       @JoinTable(name = "CustomerPassports",
            joinColumns = @JoinColumn(name="customer_fk"),
            inverseJoinColumns = @JoinColumn(name="passport_fk")
       )
       public Passport getPassport() {
       ...
    }


    @Entity public class Passport implements Serializable {
       @OneToOne(mappedBy = "passport")
       public Customer getOwner() {
       ...
    }

    Customer 通过 CustomerPassports 关联表和 Passport 关联。该关联表通过 passport_fk 外键指向 Passport 表，该信心定义为 inverseJoinColumns 的属性值。通过 customer_fk 外键指向 Customer 表，该信息定义为 joinColumns 属性值。

===========================================================================================================================================

Netstat命令解读
Category: 零｜后而聚 Date: 2010/05/28

怎样查别人的IP？怎样查自己的IP呢？我系统的哪些段口是开的？我怎样知道我的系统是否被安装了木马程序？

其实这些问题（还有一些相似的问题）有一个简单的答案：Netstat命令!

微软公司故意将这个功能强大的命令隐藏起来是因为它对于普通用户来说有些复杂。

———————————————————–

Netstat 的定义

好，在我们继续之前，我们要先知道Netstat是到底用来做什么的，它可以用来获得你的系统网络连接的信息（使用的端口，在使用的协议等），收到和发出的数据，被连接的远程系统的端口，Netstat在内存中读取所有的网络信息。

在Internet RFC标准中，Netstat的定义是：

Netstat是在内核中访问网络及相关信息的程序，它能提供TCP连接，TCP和UDP监听，进程内存管理的相关报告。

———————————————————–

netstat 参数

现在我们在对Netstat有了一定的了解之后就可以来使用它了，如果你打开了DOS窗口，你可以用以下命令来获取有关Netstat的帮助信息。

C:>netstat /?

NETSTAT [-a] [-b] [-e] [-n] [-o] [-p proto] [-r] [-s] [-v] [interval]

-a            显示所有连接和监听端口。

-b            显示包含于创建每个连接或监听端口的

可执行组件。在某些情况下已知可执行组件

拥有多个独立组件，并且在这些情况下

包含于创建连接或监听端口的组件序列

被显示。这种情况下，可执行组件名

在底部的 [] 中，顶部是其调用的组件，

等等，直到 TCP/IP 部分。注意此选项

可能需要很长时间，如果没有足够权限

可能失败。

-e            显示以太网统计信息。此选项可以与 -s

选项组合使用。

-n            以数字形式显示地址和端口号。

-o            显示与每个连接相关的所属进程 ID。

-p proto      显示 proto 指定的协议的连接；proto 可以是

下列协议之一: TCP、UDP、TCPv6 或 UDPv6。

如果与 -s 选项一起使用以显示按协议统计信息，proto 可以是下列协之一:

IP、IPv6、 ICMP、ICMPv6、TCP、TCPv6、UDP 或 UDPv6。

-r            显示路由表。

-s            显示按协议统计信息。默认地，显示 IP、

IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 和 UDPv6 的统计信息；

-p 选项用于指定默认情况的子集。

-v            与 -b 选项一起使用时将显示包含于

为所有可执行组件创建连接或监听端口的

组件。

———————————————————

netstat 实战

netstat 打开方法假设在Windows命令下操作,点击开始,在运行框内输入cmd，回车，进入命令行模式。

下面我们试试每个命令并查看结果，用来理解当我们执行命令后发生了什么，显示出的信息是什么意思？

首先，我们使用Netstat的-a参数命令。

–a            显示所有连接和监听端口。

实战：在提示符下输入netstat -a

Active Connections

Proto Local Address          Foreign Address        State

TCP    123456A:epmap 123456A:0      LISTENING

TCP    123456A:microsoft-ds 123456A:0      LISTENING

TCP    123456A:1029   123456A:0      LISTENING

TCP     123456A:2072   220.181.9.13:http      CLOSE_WAIT

UDP    123456A:bootpc *:*

UDP    123456A:microsoft-ds *:*

UDP    123456A:isakmp *:*

UDP    123456A:4500   *:*

UDP    123456A:ntp    *:*

UDP    123456A:1176   *:*

UDP    123456A:1900   *:*

UDP    123456A:2019   *:*

UDP    123456A:ntp    *:*

UDP    123456A:netbios-ns *:*

UDP    123456A:netbios-dgm *:*

UDP    123456A:1900   *:*

UDP    123456A:ntp    *:*

UDP    123456A:1900   *:*

我们对其中的术语进行讲解：

Active Connections，就是活动连接

Proto(协议) Local Address (本地)   Foreign Address(远程) State(状态)

协议（Proto）包括： TCP 和 UDP 协议

本地（Local Address）：123456A:epmap

123456A 本地机器名； epmap 说明135端口没有关闭

另外，ankit指本地已打开端口1031；

microsoft-ds是 windows提供的允许远程用户连接的端口（TCP445)这曾经是win2K的一个拒绝服务漏洞；

netbios-ssn指本地已打开 139端口，139端口是NetBIOS Session端口，用来文件和打印共享；

bootpc，bootps(bootpc) 是因为dhcp的服务和客户分别用udp的67与68地址来分配和获取IP地址的。注：dhcp来源于bootp(主机引导协议)，它是主机在boot时靠udp广播来获取ip地址.

netbios-ns，即 netbios_ns_u,137,netbios name service（netbios名称服务）；

netbios-dgm，即 netbios_dgm_u,138,netbios datagram service（netbios数据包服务）；

ntp ，　网络校时协议

Foreign Address(远程)    220.181.9.X:http

远程机器名 220.181.9.X;

远程端口：http

状态：CLOSE_WAIT（已经建连接，准备断开）

另外， LISTENING表示打开并等待别人连接的端口；

SYN_SENT 表示请求连接；

ESTABLISHED 表示连接成功；

time_wait 表示系统在等待客户端的相应。

-a参数常用于获得你的本地系统开放的端口，用它您可以自己检查你的系统上有没有被安装木马。如果您发现下面的信息：

Port 12345(TCP) Netbus

Port 31337(UDP) Back Orifice 　祝贺!您中了最常见的木马!

如果你需要木马列表的话，去国内的H站找找；当然，我的博客上也有，不太全。

*****************************************************************

#一些原理：也许你有这样的问题：「在机器名后的端口号代表什么？」

例子：ankit:1052

小于1024的端口通常运行一些网络服务，大于1024的端口用来与远程机器建立连接，比如，你的浏览器在建立一个与www.163.com的连接，这时你的机器将打开一个随意的但大于1024的端口用于连接163的伺服器。

*****************************************************************

继续我们的探讨，使用-n参数。（Netstat -n)

Netstat -n基本上是-a参数的数字形式：

C:>netstat -n

Active Connections

Proto Local Address          Foreign Address        State

TCP    222.89.171.180:2508    220.181.9.13:80        CLOSE_WAIT

TCP    222.89.171.180:2522    220.165.9.62:80        TIME_WAIT

通过比较，发现有两点不同。

1 -n参数命令用IP地址代替机器名；但是如果对方电脑如果禁用了netbios,那么用参数-a,检测的结果也是IP地址。

2 Netstat -n命令不显示非TCP连接的数据。

-n参数通常用于查自己的IP时使用，也有些人使用他是因为他们更喜欢用数字的形式来显示主机名。

得到IP等于得到一切，它是最容易使机器受到攻击的东东，所以隐藏自己IP，获得别人的IP对hacker来说非常重要，现在隐藏IP技术很流行，但那些隐藏工具或服务真的让你引身吗？答案是：它们不能使你完全隐身。下面例子用来简单说明如何获得IP。

OICQ或ICQ是很流行的聊天软件（很容易在MM身上浪费时间），他们虽然不显示用户的IP，但都是「穿马甲的IP地址」，用下面的方法得到其他用户的IP。

1 看一个DOS窗口，打入Netstat -n获得你系统已经打开的端口和远程连接列表。

2 然后打开OICQ，给「受害者」发信息。

3 当你们还在聊天的时候，返回DOS窗口，再打入Netstat -n命令，你将发现一个显示新连接的IP地址，这个就应该是「受害者」的IP。（也有其他的情况…)

到目前为止，我们讨论了『-a』和『-n』及一些应用，并发现在屏幕上返回和显示的连接不是一个详尽的协议。这意味着它显示了TCP连接，UDP等，假如你想看到那个连接属于UDP连接，你需要用 -p参数。

通常的Netstat的-p参数格式如下：

Netstat -p xxx

xxx可以是UDP或TCP，我们用显示TCP连接的例子来理解如何使用-p参数。

C:>netstat -p tcp

C:\Documents and Settings\Administrator>netstat -p tcp

Active Connections

Proto Local Address          Foreign Address        State

TCP    123456A:2525   220.181.37.55:http     CLOSE_WAIT

TCP    123456A:2528   220.181.43.129:http    CLOSE_WAIT

这是个与-a，-n参数基本一样的变种。让我们继续看-e参数。

C:>netstat -e

Interface Statistics

Received            Sent

Bytes                     129605977        54402160

Unicast packets              104689          113520

Non-unicast packets             124             138

Discards                          0               0

Errors                            0               0

Unknown protocols             92829

有些质量不好的modems不显示输出或接受的数据包，用这个命令可以解决这个问题，你也可以用它查看你的机器在处理TCP/IP过程中的错误。

我要讲解下一个参数-r，显示路由表。这个命令有点难理解，而且涉及到其他方面的知识。下面我仅给出例子来理解-r参数。（在电脑方面，只要我们想做，我们就会有收获）

C:>netstat -r

Route Table

Active Routes:

Network Address Netmask Gateway Address Interface Metric

0.0.0.0 0.0.0.0 203.94.251.161 203.94.251.161 1

127.0.0.0 255.0.0.0 127.0.0.1 127.0.0.1 1

203.94.251.0 255.255.255.0 203.94.251.161 203.94.251.161 1

203.94.251.161 255.255.255.255 127.0.0.1 127.0.0.1 1

203.94.251.255 255.255.255.255 203.94.251.161 203.94.251.161 1

224.0.0.0 224.0.0.0 203.94.251.161 203.94.251.161 1

255.255.255.255 255.255.255.255 203.94.251.161 203.94.251.161 1

-s 显示按协议统计信息。默认地，显示 IP、IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 和 UDPv6 的统计信息（不再详解）

-v，与-p参数类似，后面不用带协议类型。-v与 -b 选项一起使用时将显示包含于                为所有可执行组件创建连接或监听端口的组件。这个命令很好用，可用来查看启动了什么程序，在什么及路径。（不再详解）

-o ，显示与每个连接相关的所属进程 PID。我们可以与tasklist配合作用，查找启动了什么程序。（不再详解）