操作xml|json|以及框架的简单介绍

 //操作JSON
//把list对象装换为Json格式
List list=new Arraylist();
list.add();
//普通类型、List、Collection都是用JSONArray解析
JSONArray json=JSONArray.fromObject(list);
//Map、自定义类型使用JSONObject解析
JSONObject jsonObject=JSONObject.fromObject(Map|自己定义的类型); J
//向Json中装入数据
json.put("field1","field2");
String variable=json.get(index).toString();
String variable2=json.getString("");
//把json装换为字符串
String jsons=json.toString();

//使用百度提供的工具操作json
Gson gson = new Gson();
List list=new ArrayList();
list.add()
.....
String str=gson.toJson(list);
//JSon字符串转换为对象
List<> li=gson.fromJson(str,Student.class);


//在jquery中解析JSON
function loadInfo{
$.getJSON("URL",function(/**该方法是请求成功后的回调函数*/  date  /**data是返回的JSON对象

*/){
    $.each(data.comments,function(i,item){//data.comments是Json数组。i是遍历的index，item遍

历的值
    $(‘#info’).append(
    "<div>"+item.id+"</div>"+
    .............
         )

    });
});
}






//操作ＸＭＬ
//定义一个DOM解析器工厂实例
DocumentBuildFactory factory=DocumentBuildFactory.newInstance();
DocumentBuilder dom=factory.newDocumentBuilder();
File file=new File("XXXXXXX");
Document doc=dom.parse(file);
Element root=doc.getDocumentElement();
NodeList nodeList=root.getChildNodes();
for(int i=0;i<nodeList.getLength();i++){
  Node stu=nodeList.item(i);
  Element stuElement=(Element)stu;
  system.out.print(stuElement.getAttribute("field"));
}

//使用dom4j操作xml文件
将字符串装换为XML文件
String xmlStr=""
Document document=DocumentHelper.parseText(xmlStr);
Element root=document.getDocumentElement();
NodeList nodeList=root.getChildNodes();
for(int i=0;i<nodeList.getLength();i++){
    Node node=nodeList.item(i);
    Element el=(Element)node;
    el.getAttribute("");
}
//将XML文件转换为字符串
SAXReader reader=new SAXReader();
Document doc=reader.read("文件名")
String text = doc.asXML();    


//在jquery中使用ajax
<form id='test'>
<input type='submit' value="提交">
</form>
<script>
   var sub=$('#test').submit(function(){
    $.ajax({
         url:
         cache:false,
         type:'GET'|'POST',
         date:{"userName":userName,
           "loginName":loginName,
                "password":password_f,
           "orgId":orgId,
           "userRole":userRole,
           "phoneNum":phoneNum
               }
         success:function(data){//返回来的结果      
        var obj=eval('('+data+')');//将数据装换为json格式

             }
    });
    });
</script>


JDBC操作步骤:
加载驱动（Class.forName("org.gjt.mm.mysql")）
通过驱动管理器创建连接对象，DriverManage.getConnection();
通过连接对象，创建statement对象。
使用statement对象对数据库进行操作。
关闭connection对象和statement对象
JDBC缺点：
开发效率低
代码冗余
非面向对象
重复性工作多
容易出现sql安全问题
hibernate的核心
ORM（对象关系映射）:核心是生成sql语句。它是为了解决面向对象鱼关系数据库存在的互不匹配现象的

技术。
为了完成ORM操作，需要描述对象与数据库表之间的关系，包括类与表的映射、对象属性与字段的映射、

主键与对象属性的映射等。
映射的方式:Annotation\xml方式
Annotation是对程序的注解
hibernate的开发过程：
1、部署必要的jar包
这里就不一一举例了。
2、在工具中添加hibernate支持、创建主配置文件hibernate.cfg.xml文件\
3、配置hibernate.cfg.xml文件(该文件里面包括：配置数据库连接、运行时需要的属性)
eg:
    <property name="dialect">//这里代表方言的意思
         org.hibernate.dialect.Oracle9Dialect
    </property>
    <property name="connection.url">//地址
         jdbc:oracle:thin:@10.0.0.188:1521:ORCL
    </property>
    <property name="connection.username">jbit</property>
    <property name="connection.password">bdqn</property>
    <property name="connection.driver_class">//驱动
        oracle.jdbc.driver.OracleDriver
    </property>
操作过程中，所有的实体对象必须实例化。
添加映射文件
这里采用的是xml进行映射
如:Student.hbm.xml
<hibernate-mapping>
   <class name="com.phome.entity.Student" table="student">
    <id name="stuId" column="stuid">
         <generator class="increment"></generator>//每次把主键加1，一般在这个地方使用

native让数据库自己去处理
    </id>
   <property name="stuName" column="name"></property>
   <property name="stuAge" column="age"></property>
   </class>
</hibernate-mapping>
在hibernate.cfg.xml文件里面配置
<session-factory>
    <property name="show_sql"></property>//显示sql语句
    <property name="format_sql"></property>//格式化显示的sql语句
    <mapping resource="com/phome/Student.hbm.xml"></mapping>
</session-factory>
hibernate的配置结束，接下来是操作数据库：
一共分为一下几个步骤：
1、读取并解析配置文件
Configuration conf=new Configuration().configue();
2、读取并解析映射信息，创建sessionFactory
SessionFactory factory=conf.buildSessionFactory();
3、打开session
Session session=factory.openSession();
4、开始事务（一般操作单条数据的时候不需要）
Transaction tx=session.beginTransaction();
5、数据库操作
session.save(object);
6、提交事务
tx.commit();
7、关闭session
session.close();
其中：SessionFactory需要读取Hibernate主配置文件，获取数据库连接所必要的条件。它是创建

session的容器。
    session对JDBC中一系列对象的进一部封装。它可以操作数据库中的数据。
hibernate的执行过程：
1、产生Session对象
2、产生实体对象
3、操作数据库
4、提交或者回滚事务
5、关闭session
hibernate中实体的三种状态：
自由态（刚创建出来，还没有持久化，不处于session的缓存中）
持久态（已经持久化，在session缓存中存在）
游离态(已经持久化，但是在session缓存中不存在)
session中的方法：
load是懒加载，get是立即加载。
merge操作后，对象依然是游离态。
如果session中存在两个主键值相同的对象，调用saveOrUpdate操作时会出现异常。
hibernate查询：HQL查询、Criteria查询、本地SQL
使用HQL的步骤
1、读取并解析配置文件
Configuration cf=new Configuration.configure();
SessionFactory sf=cf.buildSesssionFactory();
Session session=sf.openSession();
String hql="XXXXXXXXXXXXXX";
Query query=session.createQuery(hql);
List<T> list=query.list();
在hibernate中提供了两种缓存：一级缓存、二级缓存。
一级缓存：在Session中实现。当关闭session时一级缓存就消失。
二级缓存：在SessionFactory中实现，同一个SessionFactory的所有Session实例共享。
配置二级缓存：在hibernate.cfg.xml中添加
<property name="hibernate.cache.provider_class">
    net.sf.ehcache.hibernate.EhCacheProvider
</property>
在ClassPath下创建ehcache.xml文件    
<ehcache>
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
        maxElementsInMemory="10000“ 缓存中最大允许保存的对象数量
        eternal="false“             缓存中数据是否为常量
        timeToIdleSeconds="120“     缓存数据钝化时间，单位为秒
        timeToLiveSeconds="120“     缓存数据生存时间，单位为秒
        overflowToDisk="true“       内存不足时，是否启用磁盘缓存
        />
</ehcache>
在hibernate映射文件里面配置：
eg:
<class name="com.phome.Student" table=“student">
    <cache usage=“read-only”/>  使用缓存
</class>

Spring 
IOC(依赖注入) ：在程序运行前，将需要依赖的对象以及对象之间的关系初始化完毕。
优点：降低对象之间的耦合。依赖注入的方式：set注入、构造方法注入、对象注入、值注入、集合注入。
Bean的生命周期：
实例化bean对象、设置对象属性、设置相关依赖、回调init-method方法、使用bean对象、回到destory方法。
spring中bean的注解：@Componet（组件）、@Repository(仓库)、@Service(业务)、@Controller(控制器)
AOP（面向切面编程）

spring与hibernate的整合：
实际上就是把hibernate里面的dateSource\sessionFactory交给spring管理。网上教程很多： http://blog.csdn.net/ufoer23/article/details/314479

Struts2
优点：是一种无入侵式设计。
struts2最核心的就是拦截器，自身就是由一堆的拦截器组成。
Struts2在MVC架构中，充当控制器的作用。使用package将path与action映射。

struts2搭建流程
1、添加支持
2、编写配置文件


1、包级别result
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
" http://struts.apache.org/dtds/struts-2.0.dtd ">
<struts>
    <!--配置WEB应用默认的编码集，以后就不需要再在每个界面中去写HttpServletRequest的

setCharacterEncoding方法了-->
    <constant name="struts.i18n.encoding" value="UTF-8"/>
    <!--设置是否缓存静态内容，默认为true。开发阶段最好关闭-->
    <constant name="struts.serve.static.browserCache" value="false"/>
    <!--struts配置文件修改后，系统是否自动重新加载该文件，默认值为false，开发阶段最好打

开-->
    <constant name="struts.configuration.xml.reload" value="true"/>
    
    
    <!--注意包名虽然可以任意取，但是必须要唯一。namespace就是之后请求的路径，该例子中请

求路径为/struts/save.action。namespace可有可无。-->
    <package name="user" namespace="/struts" extends="strus-default">
        <global-results>
        <result name="error">/error.jsp</result>当Action类的业务方法返回值是error的

时候，转向/error.jsp视图。
        </global-results>
        <action name="save" class="com.phome.action.saveAction" method="save">
        <result name="success">/WEB-INF/page/success.jsp</result><!--这里默认会有个

type="dispatcher"   type里面的值还有：redirect 重定向的方式跳转。redirectAction 重定向的方

式跳转到其他的Action中   chain 使用请求转发的方式跳转到其他的Action中-->
    <package>
</struts>

2、全级别Result
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
" http://struts.apache.org/dtds/struts-2.0.dtd ">
<struts>
   <constant name="struts"
    <package name="lala" extends="struts-default">
    <global-result>
        <result name="error">/error.jso</result>
    </global-result>
</struts>
<package name="lala11" namespace="student" extends="lala">
    <action name="save" class="com.phome.action.SaveAction" method="save">
         <result name="success">/index.jsp</result>
    </action>
</package>
<package name="lala12" namespace="student" extends="lala">
    <!--使用通配符，请求路径可以是这样子

的/student/deleteStudent|/student/deleteTeacher-->
    <action name="delete*" class="com.phome.action.DeleteAction" method="delete">
         <result name="success">/manage.jsp</result>
    </action>
</package>



3、在web.xml文件中配置启动
<filter>
     <filter-name>
    strus2
     </filter-name>
    <filter-class>
        org.apache.strus2.dispatcher.ng.filter.StrusPrepareAndExecuteFilter
    </filter-class>
</filter>
   <filter-mapping>
    <filter-name>strus2</filter-name>
    <url-pattern>/*</url-pattern><!--* 可以表示多种后缀，如.action,.do。这里也可以是

do/action，根据自己喜欢的方式定义-->
   </filter-mapping>
4、定义Action
    ......  
   public String save(Student student){
     .......
    return success;
    }
5、定义视图 (success.jsp)

Struts2的请求流程：
StrutsPrepareAndExecuterFilter是Struts2的核心，它负责拦截由配置文件中指定的用户的请求。当用

户请求达到是，它会过滤用户的请求，如果请求路径符合配置的话，会转入struts2框架处理。当转入 

struts2框架的时候，会经过一系列的拦截器，然后到达action.Struts2对用户的每次请求都会创建一个

Action,所以Struts2中的线程是安全的。

struts2中获取参数的方法：
在struts2中没有request对象，但是替代它的是ServletActionContext类（能够获取内置对象）和

ActionContext类(能够像范围中保存数据)。


SHH整合
步骤：
1、添加jar包
2、添加数据库连接信息（dbconfig.properties）
driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost/.....
user=root
password=root
maxPoolSize=30//最大存放30个连接对象
initialPoolSize=5//每次初始化5个连接对象
3、添加spring配置文件(创建applicationContext.xml文件\导入c3p0.jar)
<!-- 数据基本配置 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
      <property name="locations">
    <list>
        <value>classpath:dbconfig.properties</value>
    </list>
      </property>
</bean>
<!--配置数据库连接池-->
<beanid="c3p0DataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <propertyname="driverClass"value="${driverClass}"/>
        <propertyname="jdbcUrl"value="${jdbcUrl}"/>
        <propertyname="user"value="${user}"/>
        <propertyname="password"value="${password}"/>
        <propertyname="maxPoolSize"value="${maxPoolSize}"/>
        <propertyname="initialPoolSize"value="${initialPoolSize}"/>
    </bean>
<!--配置sessionFactory-->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 注入数据源 -->
        <propertyname="dataSource"ref="c3p0DataSource"/>
        <!-- 加载映射文件 -->
        <propertyname="mappingResources">
            <list>
                <value>com/phome/po/Grade.hbm.xml</value>
                <value>com/phome/po/Student.hbm.xml</value>
            </list>
        </property>
        <!-- 设置基本属性 -->
        <propertyname="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQLDialect
                hibernate.show_sql=true
                hibernate.format_sql=true
            </value>
        </property>
    </bean>
<!-- 配置template，并注入sessionFactory |HibernateTemplate提供非常多的常用方法来完成基本的

操作，比如通常的增加、删除、修改、查询等操作-->
    <bean id="template"class="org.springframework.orm.hibernate3.HibernateTemplate">
        <!-- 注入sessionFactory -->
        <propertyname="sessionFactory" ref="sessionFactory"/>
    </bean>

<!-- 配置事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <propertyname="sessionFactory"ref="sessionFactory"></property>
    </bean>

    <!-- 打开事务驱动器 -->
    <tx:annotation-driventransaction-manager="transactionManager"/>

    <!-- 配置bean的注入方式，以注解（以@开始）的方式注入bean -->
    <!-- 以注解方式注入bean -->
    <context:component-scanbase-package="com.phome"/>
    <!-- 以注解方式注入bean的属性 -->
    <context:annotation-config/>

4、添加struts配置文件(设置将Action交给spring管理)
<struts>
    <!-- 与Spring集成的常量，让Spring接管Struts去创建Action对象 -->
     <constantname="struts.objectFactory" value="spring"/>
     <packagename="student"namespace="/stu"extends="struts-default">
    <action name="list*" class="com.phome.struts2.actions.StudentAction"method="list">
    <result>/list.jsp</result>
    </action>
     </package>
</struts>

5、配置web.xml文件（需要启动struts2和spring容器）
<!-- 指定Spring配置文件的路径 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 实例化Spring容器 -->
    <listener>
      <listener-class>
              org.springframework.web.context.ContextLoaderListener
          </listener-class>
    </listener>
    <!-- Struts2配置 -->
    <filter>
       <filter-name>struts2</filter-name>
         <filter-class>    

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
         </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

配置完成，在实际开发中。需要注意@service\@reposity\controller上个注解。

面试复习1:

重载与重写的区别：
重载：让类以统一的方式处理不同类型的数据的一种手段。它是类中多态性的一种表现。
重写:子类继承父类，为了实现某些功能而对现有方法的重写定义。他是子类与父类之间多态性的一种表现。
他们都是实现多态性的表现。

序列化是用来处理对象流的机制，对象流可以用来在网络中传输。它是为了解决对象流在进行读写的过程中发生的问题。
struts2的请求过程：
当用户发出http请求的时候，根据web.xml配置，该请求被filterDispatch接收。根据struts.xml配置文件找到响应的Action和类,通过IOC，将值注入给action.action调用逻辑组件处理逻辑

业务这里包含数据的验证。action执行完毕后，更加它返回的结果跳转到相应的界面。

hibernate的请求过程：
1、读取并解析配置文件。
2、读取并解析配置文件里面的信息。
3、创建sessionFactory对象
4、利用sessionFactory对象创建session对象
5、开启事务
6、使用session持久化对象
7、提交事务
8、关闭session和sessionFactory

spring 
它是许多第三方插件的集合体，里面主要包含的东西是AOP和IOC
代理分为：
动态代理（根据每个具体类编写响应代理类|针对一个接口编写一个代理类）
静态代理
其中AOP是面向切面编程，就是像把日志、持久性等东西切入进应用程序的代码中。
AOP的主要原理是：动态代理。
其中IOC是依赖注入，就是创建一个可以构造对象的容器，然后向这些对象传递他们的协作对象。
使用spring的目的：让对象与对象之间的关系不再通过代码来关联，而是通过配置类说明管理的。

http://wenku.baidu.com/link?url=pmlx67KZA2m6T5xPfzDXFwEydPPdavRBsZsW492b2i1ByFZNo5PlKFpYBj5-aMF1lUgWCEFiT_NEwC8f5zwBhS0k5_mxCEF3G6WYs6UX6wm


面试复习2


OOP的基本思想：把组件的实现和接口分离，并让组件具有多态性。
//操作json的使用
在json中jsonObject与jsonArray区别：
JSONObject是一个{}包裹起来的一个对象(Object)，而JSONArray则是[]包裹起来的一个数组(Array)。

//org.json下
把list集合转换成json
List list=new ArrayList();
list.add(数据);
JSONArray json=JSONArray.fromObject(list);

//向json中装入数据
JSONArray json=JSONArray.fromObject(list);
json.put("键","值");
String var=json.get(index).toString();
Stirng var1=json.getString("键");
//将json转换成String
String js=json.toString();


//com.google.gson下<对象>
GsonBuild build=new GsonBuild();
Gson gson=build.create();
//以上两行可以写成
Gson gson=new Gson();
//将JavaBean转换为json字符串
String gBean=gson.toJson(对象);
//将json字符串转换为JavaBean
JavaBean bean=gson.fromJson(gBean,JavaBean.class);


//com.google.gson下<集合>
GsonBuild build=new GsonBuild();
Gson gson=build.create();
//以上两行可以写成
Gson gson=new Gson();
//指定集合属性
Type type=new TypeToken<list<UserBean>>(){}.getType();
//将集合转换为json字符串
String beanListToJson=gson.toJson(beanList,type);
//将json字符串转换为集合
list<UserBean> testBeanListFromJson=gson.fromJson(beanListToJson,type); 

JDBC的操作步骤：
1、加载驱动管理器DriverManage。
2、使用驱动管理器创建连接对象。
3、使用连接对象创建statement对象。
4、使用statement对象操作数据库。
5、关闭资源。
jdbc操作mysql数据库代码
Class.forName("org.mysql.jdbc.Driver");
Connection connect=DriverManager.getConnection("jdbc:mysql://localhost:3306/库名"，"用户名","密码");
Statement statement=connection.createConnection();
String sql="update xxx  set field1 ="+var1+" ,field2="+var2+" where field3 ="+var3+"";
int j=statement.executeUpdate(sql);
Sting sql1="select * from xxx";
ResultSet rs=statement.executeQuery(sql1);
while(rs.next()){
string name=rs.getString("name");
int age=rs.getInt("age");
}

class.forName("org.mysql.jdbc.Driver");
Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/库名","用户名","密码");
Statement statement=conn.createStatement();
string sql="";
int i=statement.executeQuery(sql);
statement.close();
conn.close();

//使用SAXReader将XML文件转换为字符串
SAXReader reader=new SAXReader();
Document doc=new Document(file);
String text=doc.asXML();

hibernate的使用流程：
1、读取并解析配置文件。
Configuration conf=new Configuration().configure();
2、读取并解析映射文件。
SessionFactory factory=conf.buildSessionFactory();
3、打开session
Session session=factory.openSession();
4、开始事务
Transaction ts=session.beginTransaction();
5、操作数据库
session.save(object);
6、提交事务
ts.commit();
7、关闭资源
session.close();




hibernate
ORM的核心：生成sql语句。
完成ORM操作需要描述对象和数据库表之间的关系，包括类与表之间的关系、类与表之间的映射、对象属性与字段的映射，主键与对象属性的映射等。
hibernate使用流程
1、读取并解析配置文件
Configuration conf=new Configuration.configure();
2、读取并解析映射文件
SessionFactory factory=conf.buildSessionFactory();
3、打开session
Session session=factory.openSession();
4、启动事务
Transaction ts=new Transaction();
5、操作数据库
session.save(object);
6、提交事务
ts.commit();
7、关闭资源
session.close();
hibernate中的三种状态
游离态（已经持久化，但是与session没有关联）、自由态(刚创建出来，没有持久化，与session没有关联)、持久态（已经持久化，与session有关联）。
hibernate中提供了两种缓存：
1、一级缓存（在session中实现，关闭 session时一级缓存就消失）。
2、二级缓存（在sessionFactory中实现，同时一个sessionFactory的所有session实例共享）。



spring 
在spring里面主要的内容是IOC与AOP
IOC(依赖注入)：在程序运行之前，将需要依赖的对象以及对象之间的关系都完成初始化。
实质：它就相当于是一个生产和管理bean的容器，原来需要new的东西，现在都交给IOC来完成。
非单例bean：每次调用都生产一个新的bean。
单例bean:与非单例相反。
依赖注入的方法：
1、set注入。
2、注解注入。
3、构造方法注入。
AOP（面向切面编程）：将程序中的交叉业务逻辑封装成一个切面，然后注入到目标中去。
实质：调用某个方法之前和之后，自动执行一系列自定义语句。

struts2的工作流程：
StrutsPrepareAndExecuteFilter是struts2的核心，它负责拦截由配置文件中指定的用户请求。
当用户请求达到的时候，StrutsPrepareAndExecuteFilter会获取请求。如果请求符合配置的话，会将请求交给struts2框架进行处理。当进入struts2框架之前会经过一系列的拦截器，然后到达指定的action。struts2会对用户的每次请求都创建一个action。


struts2的工作流程：
当用户请求达到时，由StrutsPrepareAndExecuteFilter拦截用户请求。当用户请求与配置文件符合时。会将用户请求交给struts2框架，在进入框架之前会经过一系列的拦截器。然后进入到指定的action。struts2会为每一个请求创建一个action。
在struts2中没有 request对象，但是它有ServletActionContext类。它可以获取内置对象。


HashTable与HashMap的区别：
HashMap是非线程安全的，HashTable是线程安全的。
HashMap可以让null保存在实体的键值对中，而hashTable是不允许的。
HashTable的方法是sychronize的，在多线程访问HashTable的时候，不需要为它的方法实现同步。而HashMap则需要为其实现同步方法。

同步和异步的区别，在什么情况下使用：
如果数据在多个线程之间共享，就需要使用到同步。
如果应用程序在对象上调用了一个需要花费很长时间来执行的方法，不希望让程序等待的时候，可以采用异步。
栈是采用先进后出的一个线性集合，而堆是栈的一个组成单元。

数据连接池的工作机制：
当java服务器启动的时候，会创建一定数量的池连接，并一直维持不少于此数目的池连接。客服端需要连接时，池驱动程序会返回一个未被使用的池连接并将其标记为忙。如果当前没有空闲的池连接，池驱动程序就会新建立一定数量的池连接。当使用的池连接调用完后，池驱动程序将会回收，并为其标记为空闲。
equal比较的是内容，而==比较的是地址。

垃圾回收机制：分代复制垃圾回收、标记垃圾回收、增量垃圾回收。
线程是指程序运行时，可以执行代码的一个单位。每个程序都至少有一个线程。线程的状态：运行、就绪、挂起、结束。

通过调用system.gc()方法主动通知虚拟机进