BlogJava-Java in Action 移動互聯網http://www.ymeg.top/action/.....zh-cnSun, 25 Aug 2019 06:35:05 GMTSun, 25 Aug 2019 06:35:05 GMT60MySQL集群之讀寫分離http://www.ymeg.top/action/archive/2011/10/18/361499.html我心依舊我心依舊Tue, 18 Oct 2011 01:58:00 GMThttp://www.ymeg.top/action/archive/2011/10/18/361499.htmlhttp://www.ymeg.top/action/comments/361499.htmlhttp://www.ymeg.top/action/archive/2011/10/18/361499.html#Feedback0http://www.ymeg.top/action/comments/commentRss/361499.htmlhttp://www.ymeg.top/action/services/trackbacks/361499.html
N年沒寫BLOG了。好了廢話不多說。直接上配置文件。都有注視如果有問題請聯系我新浪微博http://weibo.com/javamail


###############################主庫配置###############################
#主機標示,整數
server-id=1
#確保此文件可寫
log_bin=C:\mysql-bin.log
#主機,讀寫都可以
read-only=0
#需要備份數據,多個寫多行
binlog-do-db=appcom
#不需要備份的數據庫,多個寫多行
binlog-ignore-db=mysql
###############################主庫配置###############################
###############################從庫配置###############################
#server-id=2
#log_bin=C:\mysql-bin.log
#master-host=172.16.33.44
#master-user=root
#master-pass=5719
#master-port=3306
#如果從服務器發現主服務器斷掉,重新連接的時間差(秒)
#master-connect-retry=5
#只復制某個庫
#binlog-do-db=appcom
#不復制某個庫
#binlog-ignore-db=mysql
###############################從庫配置###############################


我心依舊 2011-10-18 09:58 發表評論
]]>
這個BLOG五年沒上了。歡迎同行做JAVA的朋友加我的微博http://t.qq.com/javamailhttp://www.ymeg.top/action/archive/2011/03/17/346481.html我心依舊我心依舊Thu, 17 Mar 2011 09:54:00 GMThttp://www.ymeg.top/action/archive/2011/03/17/346481.htmlhttp://www.ymeg.top/action/comments/346481.htmlhttp://www.ymeg.top/action/archive/2011/03/17/346481.html#Feedback0http://www.ymeg.top/action/comments/commentRss/346481.htmlhttp://www.ymeg.top/action/services/trackbacks/346481.html

我心依舊 2011-03-17 17:54 發表評論
]]>
SSH+AJAX整合簡明實例http://www.ymeg.top/action/archive/2008/11/03/238427.html我心依舊我心依舊Mon, 03 Nov 2008 12:36:00 GMThttp://www.ymeg.top/action/archive/2008/11/03/238427.htmlhttp://www.ymeg.top/action/comments/238427.htmlhttp://www.ymeg.top/action/archive/2008/11/03/238427.html#Feedback1http://www.ymeg.top/action/comments/commentRss/238427.htmlhttp://www.ymeg.top/action/services/trackbacks/238427.html
com.michael.mvc工程
lib1
lib2
lib3



                                                        by Michael


我心依舊 2008-11-03 20:36 發表評論
]]>
原創 Struts Spring Hibernate (SSH) 整合實例http://www.ymeg.top/action/archive/2007/08/28/140566.html我心依舊我心依舊Tue, 28 Aug 2007 08:17:00 GMThttp://www.ymeg.top/action/archive/2007/08/28/140566.htmlhttp://www.ymeg.top/action/comments/140566.htmlhttp://www.ymeg.top/action/archive/2007/08/28/140566.html#Feedback21http://www.ymeg.top/action/comments/commentRss/140566.htmlhttp://www.ymeg.top/action/services/trackbacks/140566.html首選創建web.xml 主要是配置Struts的ActionServlet和Spring的字符過濾器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
 
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
 
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts/struts.xml</param-value>
    </init-param>
    <init-param>
      <param-name>debug</param-name>
      <param-value>3</param-value>
    </init-param>
    <init-param>
      <param-name>detail</param-name>
      <param-value>3</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
 
  <!-- session超時定義,單位為分鐘 -->
  <session-config>
    <session-timeout>10</session-timeout>
  </session-config>
 
  <!-- 默認首頁定義 -->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.html</welcome-file>
  </welcome-file-list>
 
</web-app>

 

然后創建struts.xml(String配置文件) 要注意這里集成了Spring插件,把全部Spring配置文件注入到ContextLoaderPlugIn中

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>

  <form-beans>
 <form-bean name="loginVO" type="com.vo.LoginVO" />
  </form-beans>

  <global-forwards>
   <forward name="error" path="/error.jsp"/>
  </global-forwards>

  <action-mappings>
   <action path="/login"
     name="loginVO"
      type="org.springframework.web.struts.DelegatingActionProxy"
      parameter="action"
      scope="request">
      <forward name="login" path="/login.jsp"/>
      <forward name="index" path="/index.jsp"/>
    </action>
  </action-mappings>

  <!-- 集成Spring插件 -->
  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/spring/*.xml" />
  </plug-in>

</struts-config>


配置Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <!-- 讀入屬性文件 -->
 <bean id="propertyConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
   <list>
    <value>classpath:hibernate.properties</value>
   </list>
  </property>
 </bean>

 <!-- 配置數據源,可以其他方式 -->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
     <property name="driverClassName" value="${hibernate.driverClassName}" />
  <property name="url" value="${hibernate.url}" />
  <property name="username" value="${hibernate.username}" />
  <property name="password" value="${hibernate.password}" />
     <property name="maxActive" value="${hibernate.maxActive}" />
  <property name="maxIdle" value="${hibernate.maxIdle}" />
  <property name="maxWait" value="${hibernate.maxWait}" />
    </bean>

 <!-- 配置Hibernate的Session工廠,注入數據源、映射文件 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
     <property name="dataSource">
        <ref local="dataSource"/>
     </property>
        <property name="mappingResources">
            <list>
                <value>com/po/login.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
       <props>
         <prop key="hibernate.dialect">${hibernate.dialect}</prop>
         <prop key="hibernate.show_sql">${hibernate.showSQL}</prop>
       </props>
     </property>
    </bean>

 <!-- 聲明Hibernate事務管理,注入Session工廠 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory">
       <ref local="sessionFactory"/>
     </property>
   </bean>

 <!-- 配置事務代理,注入事務管理transactionManager,由Spring來代理事務,設置事務屬性 -->
    <bean id="transactionProxy" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
     <property name="transactionManager">
       <ref bean="transactionManager"/>
     </property>
     <property name="transactionAttributes">
       <props>
           <prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="remove*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="create*">PROPAGATION_REQUIRED,-Exception</prop>
               <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
               <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
               <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
               <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
               <prop key="*">PROPAGATION_REQUIRED</prop>
       </props>
     </property>
    </bean>
</beans>


配置Action將Service注入到Action

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <!-- 配置Action,singleton屬性設置為false表示不使用單例,每次都重新創建實例,避免并發問題,注入事務管理的Service -->
  <bean name="/login" class="com.action.LoginAction" singleton="false">
   <property name="loginService">
         <ref bean="loginService"/>
        </property>
  </bean>
</beans>

配置Service將Dao注入到Service

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <!-- 配置事務代理Service,先將Dao注入到Service,再將Service注入給事務代理 -->
    <bean id="loginService" parent="transactionProxy">
     <property name="target">
      <ref bean="loginTempService"/>
     </property>
   </bean>
   <bean id="loginTempService" class="com.service.LoginService">
        <property name="loginDao">
         <ref bean="loginDao"/>
        </property>
    </bean>
</beans>

配置Dao 注入Session工廠

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <!-- 配置Dao,注入Session工廠 -->
    <bean id="loginDao" class="com.dao.LoginDao">
        <property name="sessionFactory">
         <ref bean="sessionFactory"/>
        </property>
    </bean>
</beans>

數據源屬性文件(注意不是Hibernate的配置文件,是為了讓Spring讀入的)

hibernate.dialect=org.hibernate.dialect.SQLServerDialect
hibernate.driverClassName=com.mysql.jdbc.Driver
hibernate.url=jdbc:mysql://127.0.0.1:3306/ssh
hibernate.username=root
hibernate.password=5719
hibernate.showSQL=true
hibernate.maxActive=50
hibernate.maxIdle=30
hibernate.maxWait=1000

log4j配置文件(簡單)

log4j.rootLogger=ERROR,console,file

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%-5p %d [%F,%L] - %m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=F:\\SSH.log
#log4j.appender.file.MaxFileSize=100000KB
#log4j.appender.file.MaxBackupIndex=1
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%-5p %d [%F,%L] - %m%n

下面是類文件

package com.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;

import com.service.LoginService;
import com.vo.LoginVO;

public class LoginAction extends DispatchAction {

 private Log logger = LogFactory.getLog(LoginAction.class);
 private LoginService loginService;

 public void setLoginService(LoginService loginService) {
  this.loginService = loginService;
 }

 public ActionForward login(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) {
  try {
   LoginVO loginVO = (LoginVO) form;
   String username = loginVO.getUsername();
   String password = loginVO.getPassword();
   System.out.println(username+password);
   if(loginService.validate(username, password)) {
    return mapping.findForward("index");
   }
   return mapping.findForward("error");
  } catch (Exception e) {
   logger.error(e);
   return mapping.findForward("error");
  }
 }

 public ActionForward save(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) {
  try {
   LoginVO loginVO = (LoginVO) form;
   loginService.saveUser(loginVO);
   return mapping.findForward("index");
  } catch (Exception e) {
   logger.error(e);
   return mapping.findForward("error");
  }
 }
}



package com.dao;

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.po.LoginPO;

public class LoginDao extends HibernateDaoSupport {

 @SuppressWarnings("unchecked")
 public String getPassword(String username) {
  String hql = "from LoginPO l where l.username=?";
  List list = getSession().createQuery(hql).setString(0,username).list();
  if(list!=null && list.size()>0) {
   LoginPO loginPO = (LoginPO) list.get(0);
   return loginPO.getPassword();
  }
  return null;
 }

 public void save(LoginPO loginPO) {
  getSession().save(loginPO);
 }
}



package com.po;

import java.io.Serializable;

public class LoginPO implements Serializable {

 private static final long serialVersionUID = 1L;

 private Integer id = null;
 private String username = null;
 private String password = null;

 public Integer getId() {
  return id;
 }
 public String getPassword() {
  return password;
 }
 public String getUsername() {
  return username;
 }
 public void setId(Integer id) {
  this.id = id;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public void setUsername(String username) {
  this.username = username;
 }
}



package com.service;

import com.dao.LoginDao;
import com.po.LoginPO;
import com.vo.LoginVO;

public class LoginService {

 private LoginDao loginDao;

 public void setLoginDao(LoginDao loginDao) {
  this.loginDao = loginDao;
 }

 public boolean validate(String username,String password) {
  String pass = loginDao.getPassword(username);
  if(pass!=null) {
   if(pass.equals(password)) {
    return true;
   }
  }
  return false;
 }

 public void saveUser(LoginVO loginVO) {
  LoginPO loginPO = new LoginPO();
  loginPO.setUsername(loginVO.getUsername());
  loginPO.setPassword(loginVO.getPassword());
  System.out.println(loginVO.getUsername()+"-"+loginVO.getPassword()+":save succeed...");
  loginDao.save(loginPO);
  //故意制造異常,測試事務。
  //loginDao.save(null);
 }
}



package com.vo;

import org.apache.struts.action.ActionForm;

public class LoginVO extends ActionForm {

 private static final long serialVersionUID = 1L;
 
 private String username = null;
 
 private String password = null;
 
 public String getPassword() {
  return password;
 }
 public String getUsername() {
  return username;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public void setUsername(String username) {
  this.username = username;
 }
}

Hibernate映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="com.po.LoginPO" table="login">
        <comment></comment>
       
        <id name="id" type="int">
   <column name="id" />
   <generator class="native" />
  </id>
       
        <property name="username" type="string">
            <column name="username" not-null="true">
                <comment></comment>
            </column>
        </property>
       
        <property name="password" type="string">
            <column name="password" not-null="true">
                <comment></comment>
            </column>
        </property>
    </class>
</hibernate-mapping>

jsp頁面文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
  <form name="form" action="login.do?action=login" method="post">
   <h1>Login</h1>
   <h4>username:</h4><input name="username" type="text">&nbsp;&nbsp;&nbsp;<span id="message"></span>
   <h4>password:</h4><input name="password" type="password">
   <br>
   <br>
   <input value="提交" type="button" onclick="form.submit();">
  </form>
  <br>
  <br>
  <br>
  <form name="form" action="login.do?action=save" method="post">
   <h1>Save</h1>
   <h4>username:</h4><input name="username" type="text">&nbsp;&nbsp;&nbsp;<span id="message"></span>
   <h4>password:</h4><input name="password" type="password">
   <br>
   <br>
   <input value="提交" type="button" onclick="form.submit();">
  </form>
</body>
</html>

jar包太多太大了這里就不發了.具體什么意思都有注視,完全實例,理論知識以后在說,歡迎拍磚嘎嘎...



我心依舊 2007-08-28 16:17 發表評論
]]>
北京有換工作的沒,我們公司急聘中,高級軟件工程師,系統分析師,我們SOA項目,有興趣的可以發簡歷到huanglia@163.com http://www.ymeg.top/action/archive/2007/06/29/127111.html我心依舊我心依舊Fri, 29 Jun 2007 09:29:00 GMThttp://www.ymeg.top/action/archive/2007/06/29/127111.htmlhttp://www.ymeg.top/action/comments/127111.htmlhttp://www.ymeg.top/action/archive/2007/06/29/127111.html#Feedback1http://www.ymeg.top/action/comments/commentRss/127111.htmlhttp://www.ymeg.top/action/services/trackbacks/127111.html北京有換工作的沒,我們公司急聘中,高級軟件工程師,系統分析師,我們SOA項目,有興趣的可以發簡歷到huanglia@163.com
我QQ是147372304



我心依舊 2007-06-29 17:29 發表評論
]]>
Hibernate 解決SQL count(*)的問題.http://www.ymeg.top/action/archive/2007/06/05/122089.html我心依舊我心依舊Tue, 05 Jun 2007 03:28:00 GMThttp://www.ymeg.top/action/archive/2007/06/05/122089.htmlhttp://www.ymeg.top/action/comments/122089.htmlhttp://www.ymeg.top/action/archive/2007/06/05/122089.html#Feedback1http://www.ymeg.top/action/comments/commentRss/122089.htmlhttp://www.ymeg.top/action/services/trackbacks/122089.html// 用于hibernate 2.x
protected String getCountSql(String originalHql, net.sf.hibernate.SessionFactory sessionFactory) throws Exception {
QueryTranslator translator = new QueryTranslator(originalHql);

translator.compile((net.sf.hibernate.engine.SessionFactoryImplementor)sessionFactory, Collections.EMPTY_MAP, false);

return "select count(*) from (" + translator.getSQLString() + ") tmp_count_t";
}
// 用于hibernate 3.x
protected String getCountSql(String originalHql, org.hibernate.SessionFactory sessionFactory) throws Exception {
QueryTranslatorImpl queryTranslator = new QueryTranslatorImpl(originalHql, originalHql,
Collections.EMPTY_MAP, (org.hibernate.engine.SessionFactoryImplementor)sessionFactory);

queryTranslator.compile(Collections.EMPTY_MAP, false);

return "select count(*) from (" + queryTranslator.getSQLString() + ") tmp_count_t";
}

String strHQL = "Select count(*) From tb_po";
Long count = (Long)session.createQuery(strHQL).uniqueResult();



我心依舊 2007-06-05 11:28 發表評論
]]>
理解Session緩存機制 操縱持久化對象http://www.ymeg.top/action/archive/2007/05/24/119737.html我心依舊我心依舊Thu, 24 May 2007 07:43:00 GMThttp://www.ymeg.top/action/archive/2007/05/24/119737.htmlhttp://www.ymeg.top/action/comments/119737.htmlhttp://www.ymeg.top/action/archive/2007/05/24/119737.html#Feedback0http://www.ymeg.top/action/comments/commentRss/119737.htmlhttp://www.ymeg.top/action/services/trackbacks/119737.htmlHibernate向我們提供的主要的操縱數據庫的接口,Session就是其中的一個,它提供了基本的增,刪,改,查方法.而且具有一個緩存機制,能夠按照某個時間點,按照緩存中的持久化對象屬性的變化來更新數據庫,著就是Session的緩存清理過程.在Hibernate中對象分為三個狀態,臨時,持久化,游離.如果我們希望JAVA里的一個對象一直存在,就必須有一個變量一直引用著這個對象.當這個變量沒了.對象也就被JVM回收了.當然這個是最基本的常識了.當Session的save()方法持久化了一個對象的時候,即使這個對象的引用變量小時了.這個對象也依然存在,因為Sessoin里保存了一個這個對象的引用,當然Session緩存被清空,這個對象就OVER了.在這個對象保存在Sessoin的時候如果調用load()方法試圖去數據庫中加載一個對象,這個時候Session會先判斷緩存中有沒有這個對象,如果有了,那么就不需要去數據庫加載了.這樣可以減少訪問數據庫的頻率,還可以保證緩存中的對象于數據庫的同步.
      Session有兩個方法,一個commit()事務提交方法,還有flush()刷新緩存方法,都有著清理緩存的作用,flush()進行緩存的清理,執行一系列的SQL語句,但不會提交事務.而commit()方法會先調用flush()方法,然后在提交事務.Session還有一個方法就是setFushMode()方法,用戶設定清理緩存的時間點,主要有三種模式,默認Flush.Mode.AUTO
      1)FlushMode.AUTO Session的查詢方法,commit方法,flush方法都會清理緩存.
      2)FlushMode.COMMIT Session的commit方法,flush方法會清理緩存.
      3)FlushMode.NEVER Session的flush方法會清理緩存.
對象的臨時狀態:剛用new創建對象的時候,它還沒有被持久化,這個時候是臨時狀態.
對象的持久化狀態:已經被加入到Session的緩存中,通常所說的持久化對象就是只一個對象在這個狀態的時候.
對象的游離狀態:已經被持久化,但是不屬于Session的緩存的時候是游離狀態.

我心依舊 2007-05-24 15:43 發表評論
]]>
分析Hibernate映射的關聯關系http://www.ymeg.top/action/archive/2007/05/23/119405.html我心依舊我心依舊Wed, 23 May 2007 07:07:00 GMThttp://www.ymeg.top/action/archive/2007/05/23/119405.htmlhttp://www.ymeg.top/action/comments/119405.htmlhttp://www.ymeg.top/action/archive/2007/05/23/119405.html#Feedback8http://www.ymeg.top/action/comments/commentRss/119405.htmlhttp://www.ymeg.top/action/services/trackbacks/119405.html      Hibernate的映射關聯關系和我們現實世界里事物的關聯關系一樣.比如在UML語言中,以客戶Customer和訂單Order的關系為例.一個客戶可以發送多個訂單,而一個訂單只能屬于一個客戶,這是一對多的關聯,因此可以成為單向關聯.如果同時包含了兩兩種關聯關系,就成為雙向關聯.在關系數據庫中只有外鍵參照主鍵的關系.所以關系數據庫實際上至支持一對一,或一對多的單向關系.在類于類之間的關系中.要算多對一關系和數據庫中的外鍵參照主鍵關系最匹配了.因此如果使用單向關聯從訂單到客戶的多對一單向關聯,在訂單類中就要定義一個客戶的屬性.表示這個訂單屬于哪個客戶,而客戶類就無需定義存放訂單的集合屬性了.下面寫一個簡單的例子.
//首先定義客戶類
public class Customer implements Sreializable {
   private Long id;
   private String name;
   //省略屬性的訪問方法
}
//然后定義訂單類
public class Order implements Sreializable {
   private Long id;
   private String orderName;
   private Customer customer;
   //省略屬性的訪問方法,要注意的是Customer的訪問方法.
}
Customer類的所有屬性和CUSTOMERS表的所有屬性一一對應,創建起來就比較簡單了.下面主要看一下Order類的映射文件.
<property name="orderName" type="string">
   <column name="ORDER_NAME" length="15"/>
</property>
因為customer屬性是是Customer類型,而ORDERS表的CUSTOMER_ID是整數類型,是不匹配的.所以我們不能用普通的<property>元素來定義,而我們需要使用<many-to-one>元素來配置了.
<many-to-one name="customer" column="CUSTOMER_ID" class="包名.Customer" not-null="true"/>
<many-to-one>元素負責建立Order訂單類的customer屬性和數據庫中的CUSTOMER_ID外鍵字段之間的映射.
name:設定映射文件的屬性名
column:設定和持久化類對應的表的外鍵名
class:設定持久化類的屬性的類型,這里指定具體的類,也就是主鍵存在的類
not-null:設定為true表示customer屬性不允許為null,默認是false,這個屬性會影響到bhm2ddl工具,會為ORDERS表的CUSTOMER_ID外鍵設置為不允許空的約束,但是不會影響到hbm2java工具生長java源代碼.此外還會影響到Hibernate運行時的行為,在保存Order對象的時候會檢查customer屬性是否為null.用hbm2ddl編譯之后得到的數據庫文件如下:

create table CUSTOMERS (
   ID bigint not null,
   NAME varchar(15),
   primary key (ID)
);
create table ORDERS (
   ID bigint not null,
   ORDER_NUMBER varchar(15),
   CUSTOMER_ID bigint not null,
   primary key (ID)
);
alter table ORDERS add index FK8B7256E516B4891C (CUSTOMER_ID),
add constraint FK8B7256E516B4891C foreign key (CUSTOMER_ID) references CUSTOMERS (ID);
看到結果我們可以簡單的把<many-to-one>理解為在數據庫中,創建外鍵的作用.上邊這個例子就簡單的演示了Hibernate映射的一對一關聯關系,至于一對多的關聯關系比這個稍微復雜一點.而且可以看出,當Hibernate持久化一個臨時對象的時候,在默認的情況下它不會自動持久化關聯其他臨時對象,而是會拋出TransientObjectException異常.如果希望Hibernate持久化對象的時候也自動持久化說關聯的對象,就要把<many-to-one>元素的cascade屬性設置為save-update,表示級聯操作的意思,cascade屬性的默認值為none.當這個屬性設置OK了.數據庫就實現了級聯保存更新的操作.
      在類和類之間建好了關聯關系之后,就可以方便的從一個對象得到它關聯的對象.例如Customer customer=order.getCustomer();這樣獲得的了Customer對象了.但是如果想獲得所有屬于Customer客戶的Order訂單對象,就涉及到了一對多雙向關聯了.在內存中,從一個對象導航都另一個對象要比從數據庫中通過一個字段查詢另一個字段快的多的多,但是也給編程的時候帶來了麻煩,隨意修改一個對象就可能牽一發而動全身,所以說雙向的關聯比較復雜,但是類和類之間到底建立單向還是雙向關聯,這個要根據業務需求來決定.比如說業務需求根據指定客戶查詢客戶所有訂單,根據指定的訂單,查詢出發這個訂單的客戶.這個時候我們不妨用多對一雙向關聯處理.其實上邊的例子的映射文件已經簡歷了客戶和訂單之間的一對多雙向關聯關系,只不過要在客戶類中加一個集合的屬性:
private set orders = new HashSet();
public set getOrders() {
   return orders;
}
public void setOrders(Set orders) {
   this.orders = orders;
}
有了orders屬性,客戶就可以通過getOrders()方法或者客戶的全部訂單了,Hibernate在定義這個集合屬性的時候必須聲明為接口類型,但是不光光是Set還有Map和List,這樣可以提高程序的強壯性,就是說set方法接受的對象只要是實現了Set接口就OK.避免出現null值的現象.這里要注意的是hbm2java工具生成類的集合屬性的代碼時,不會給它初始化一個集合對象的實例,這里我們需要自己手動修改,當然不修改也是可以的.接下來還要在customer.hbm.xml映射文件里映射集合類型的orders屬性,當然這個和order表的的<many-to-one>同理,所以不能通過普通的<property>元素來設置屬性和字段的映射關系.要使用<set>元素來設置:
<set name="orders" cascade="save-update">
<key column="CUSTOMER_ID">
<one-to-many class="包名.Order">
</set>
name:設定類的屬性名
cascade:設置為save-update表示級聯保存更新,當保存或更新Customer類的時候會級聯保存更新跟它關聯的Order類.
<key>元素是用來設定跟持久化類關聯的類的外鍵
<one-to-many>元素看起來很熟悉,哦是設置外鍵的元素反過來了.這里它是用來設置所關聯的持久化類的.這里設置為和客戶關聯的訂單Order類,這里表明這個屬性里要存放一組Order類型的對象.
這個<set>元素是表示orders屬性聲明為set類型.
<set>元素還有一個inverse屬性,這個方法主要是在給已存在數據庫中的字段建立關聯的時候很有用.就是說當我們獲得數據庫中的兩個表的兩條記錄的對象customer客戶對象和order訂單對象(映射文件已經建立了他們類和類之間的關聯,但外鍵的值為null的情況下)然后我們想建立這個客戶對象和訂單對象之間的關聯,我們要先調用order.setCustomer(customer);然后在調用customer.getOrder().add(order);在Hibernate自動清理緩存的持久化對象的時候會提交兩條SQL語句.進行了兩個update操作.但是實際上只修改了一條記錄.重復的執行SQL語句是會降低系統的運行效率的,當把inverse屬性設置為true的時候,同樣的操作就會合并到一條SQL語句執行了,inverse默認為false;
      級聯刪除就很簡單了,把cascade屬性設置為delete,如果你刪除了一個客戶,程序就會先執行刪除這個客戶全部的訂單的SQL語句,然后在刪除這個客戶,所謂刪除一個持久化對象不是在內存中刪除這個對象,而是刪除數據庫中相關的記錄,這個對象依然在內存中,只不過由持久化狀態轉為臨時狀態,當這個對象的引用消失后,這個對象會被垃圾回收.但是如果我又想級聯刪除,還想級聯保存,更新的時候應該怎么辦呢?這個時候我們將cascade屬性設置為all-delete-orphan就OK了.非常簡單明了.我們還可以通過持久化類的customer.getOrder().rumove(order);解除關聯.這里的操作表示獲得客戶訂單的集合對象,然后從集合對象中刪除order的訂單,其實這種操作的意義不大,當我們不需要的這個訂單的時候完全可以刪除它,解除關聯之后如果設置了級聯刪除屬性,這個無用的記錄也是要被刪除的.其實解除關聯就是把外鍵設為null.通常我們的外鍵都要約束不可以為空.
      映射關聯還有一種多對多的關聯,是一種自身關聯關系.就是同一張表.自己和自己的關聯.比如說一張人表,地球人是人,美國人,中國人,日本人都屬于地球人,中國人有分北京人,山東人.日本人也有下一級的比如東京人.下面設想如果日本人被消滅掉了,那么東京人也應該都被沒有了吧,這就是一種關系,自身對自身的關聯關系.這就有點類似樹的結構了.下面用一個例子演示這種關系,代碼來源于孫MM的<<精通Hibernate>>一書.
public class Category implements Serializable {

    private Long id;

    private String name;

    private Category parentCategory;

    private Set childCategories;

    public Category(String name, mypack.Category parentCategory, Set childCategories) {
        this.name = name;
        this.parentCategory = parentCategory;
        this.childCategories = childCategories;
    }

    public Category() {
    }

    public Category(Set childCategories) {
        this.childCategories = childCategories;
    }

    public Category getParentCategory() {
        return this.parentCategory;
    }

    public void setParentCategory(Category parentCategory) {
        this.parentCategory = parentCategory;
    }

    public Set getChildCategories() {
        return this.childCategories;
    }

    public void setChildCategories(Set childCategories) {
        this.childCategories = childCategories;
    }
   //為了節省空間省略了id,name屬性的訪問方法

}
<hibernate-mapping >
  <class name="mypack.Category" table="CATEGORIES" >
    <id name="id" type="long" column="ID">
      <generator class="increment"/>
    </id>
    <property name="name" type="string" >
        <column name="NAME" length="15" />
    </property>
    <set
        name="childCategories"
        cascade="save-update"
        inverse="true"
        >
        <key column="CATEGORY_ID" />
        <one-to-many class="mypack.Category" />
     </set>  
   <many-to-one
        name="parentCategory"
        column="CATEGORY_ID"
        class="mypack.Category"
       />
  </class>
</hibernate-mapping>
      我覺得這種方式其實和上邊的一對多,一對一關系一樣,只不過兩個用的都是同一個類罷了.看一下例子理解上應該很簡單.      



我心依舊 2007-05-23 15:07 發表評論
]]>
映射對象標識符http://www.ymeg.top/action/archive/2007/05/22/119134.html我心依舊我心依舊Tue, 22 May 2007 07:05:00 GMThttp://www.ymeg.top/action/archive/2007/05/22/119134.htmlhttp://www.ymeg.top/action/comments/119134.htmlhttp://www.ymeg.top/action/archive/2007/05/22/119134.html#Feedback1http://www.ymeg.top/action/comments/commentRss/119134.htmlhttp://www.ymeg.top/action/services/trackbacks/119134.html      Hibernate采用對象標識符,也就是通常我們所說的OID來創建對象和數據庫表里記錄的對應關系,對象的OID和表里的主鍵對應,所以說OID是非常重要的,不應該讓程序來給它賦值.數據庫區分同一表的不同記錄是用主鍵來區分.數據庫中的主鍵最重要的3個基本要素就是不允許為null,不允許有重復值,主鍵永遠不會改變.所以通常我們設計表都會設計主鍵的值為自動增加,沒有業務邏輯含義的一組數字,當然針對每個數據庫,設置的方法也不同.但是都非常簡單.加一個屬性就可以了.
      而JAVA區分同一類的不同對象是用內存地址,在JAVA語言中判斷兩個對象的引用變量是否想相等,有以下兩種比較方式.1)用運算符"=="比較內存地址,此外還可以用Object的equals方法也是按內存地址比較.2)比較兩個對象的值是否相同,JAVA中的一些覆蓋了Object類的equals方法實現比較合適.例如String和Date類,還有JAVA包裝類.如果是String.equals(String)這種方式的比較就是比較這兩個String的值的.如果是Object原是的equals方法就是比較地址了.這點很容易混淆.
      通常,為了包裝Hibernate的OID的唯一性和不可變性,由Hibernate或者底層數據庫來給OID賦值比較合理.因此我們在編程的時候最好把持久化類的OID設置為private或者protected類型,這樣可以防止JAVA程序隨便更改OID.而OID的get方法我們還是要設置為public類型,這樣方便我們讀取. 在對象-關系映射文件里的<id元素是用來設置對象標識符OID的.type通常設置為long.而<generator子元素用來設置OID的標識符生成器,Hibernate提供了標識符生成器的接口net.sf.hibernate.id.IdentifierGenerator接口,并且提供了N多中內置的實現,和對應的縮寫.我們只要把這些實現類的類名或者所寫設置在<generator子元素的class屬性中,就能完成OID的配置了.具體的內置標識符生成器如下:
      1)increment 代理主鍵,hibernate自動以遞增的方式來生成標識符,每次增加1.
      2)identity 代理主鍵,由底層數據庫生成標識符,前提就是底層的數據庫支持自動增長的類型.
      3)sequence 代理主鍵,hibernate根據底層數據庫生成的標識符,前提是底層數據庫支持序列
      4)hilo 代理主鍵,hibernate根據higg/low算法來生成的標識符,把特定表的字段作為high的值,默認選用hibernate_unique_key表的next_hi字段
      5)native 代理主鍵,根據底層數據庫對自動生成標識符的支持能力,還選擇identity,sequence,或hilo.
      6)uuid.hex 代理主鍵,hibernate采用128位的UUID算法生成標識符,UUID算法能夠在網絡環境下生成唯一字符串標識符.不過字符串要比數據占用的空間多的多.所以不流行使用.
      7)assigned 適用于自然主鍵,由JAVA應用程序負責生成標識符,為了能讓JAVA設置OID.不能吧setId方法設置為非公共類型了,這種方式也盡量避免使用.
      這里個人覺得第一種方式,也就是說由Hibernate來生成對象標識符的方式比較好.但是這種方式的缺點是只能一個Hibernate對應一個數據庫的表.當同時創建了SeesionFactory實例的時候.兩個或者更多的Hibernate對應同一個數據庫的時候就會插入出錯.這個時候我們可以選擇第二種方式把標識符的生成工作交給底層數據庫.還有一個小知識點要注意就是OID必須定義為long,int,short類型,如果定義為byte會報異常,這里推薦用long.
      總結一下,這7中生成OID標識符的方法,increment 比較常用,把標識符生成的權力交給Hibernate處理.但是當同時多個Hibernate應用操作同一個數據庫,甚至同一張表的時候.就推薦使用identity 依賴底層數據庫實現,但是數據庫必須支持自動增長,sequence 以來底層數據庫實現,但是數據庫必須支持系列.hilo 根據特定的表實現.這三種方式了.當然針對不同的數據庫選擇不同的方法.如果你不能確定你使用的數據庫具體支持什么的情況下.可以選擇第三種.或者用native 讓Hibernate來幫選擇identity,sequence,或hilo.后邊的自然主鍵不推薦使用,因為自然主鍵就是具有業務含義的主鍵,在現在的軟件開發結構中,已經很少有人用了.下面總結一下幾種常用數據庫,可以使用的標識符類型.
      MySQL:identity數據庫底層實現,需要支持自動增長,increment由Hibernate實現,hilo用特定的表實現,
      MSSQL:identity數據庫底層實現,需要支持自動增長,increment由Hibernate實現,hilo用特定的表實現,
      Oracle:sequence數據庫底層實現,需要支持序列,increment由Hibernate實現,hilo用特定的表實現,
      以上不難發現,所有的數據庫都支持Hibernate用increment實現OID的生成,MYSQL和MSSQL數據庫底層實現支持自動增長,而Oracle支持序列,還有用特殊表的實現方式這三個數據庫都支持.還有一種實現方式適用于所有的數據庫,就是native,由Hibernate去選擇使用什么樣的方式來生成IOD對象標識符,這種方式也是跨平臺的.下面是各種設置方式的例子*.hbm.xml文件四個.例題來源孫MM的<<精通Hibernate>>一書.我非常喜歡這本書,講的非常簡單明了.感興趣的朋友可以去買一本看看(當當打7.3折哦).
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>

  <class name="mypack.HiloTester"  table="HILO_TESTER">
   
    <id name="id" type="long" column="ID">
    <generator class="hilo">
                <param name="table">hi_value</param>
                <param name="column">next_value</param>
                <param name="max_lo">100</param>
        </generator>
    </id>

    <property name="name" type="string" >
        <column name="name" length="15" />
    </property>
   
  </class>
 
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>

  <class name="mypack.IdentityTester"  table="IDENTITY_TESTER">
   
    <id name="id" type="long" column="ID">
      <generator class="identity"/>
    </id>

    <property name="name" type="string" >
        <column name="name" length="15"/>
    </property>
   
  </class>
 
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>

  <class name="mypack.NativeTester" table="NATIVE_TESTER" >
   
    <id name="id" type="long" column="ID">
      <generator class="native"/>
    </id>

    <property name="name" type="string" >
        <column name="name" length="15" />
    </property>
   
  </class>
 
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>

  <class name="mypack.IncrementTester" table="INCREMENT_TESTER" >
   
    <id name="id" type="long" column="ID">
      <meta attribute="scope-set">private</meta>
      <generator class="increment"/>
    </id>

    <property name="name" type="string" >
        <column name="NAME" length="15" />
    </property>
   
  </class>
 
</hibernate-mapping>



我心依舊 2007-05-22 15:05 發表評論
]]>
Hibernate ORM 對象-關系 映射http://www.ymeg.top/action/archive/2007/05/21/118886.html我心依舊我心依舊Mon, 21 May 2007 07:21:00 GMThttp://www.ymeg.top/action/archive/2007/05/21/118886.htmlhttp://www.ymeg.top/action/comments/118886.htmlhttp://www.ymeg.top/action/archive/2007/05/21/118886.html#Feedback2http://www.ymeg.top/action/comments/commentRss/118886.htmlhttp://www.ymeg.top/action/services/trackbacks/118886.html       Hibernate的持久化類使用的是JavaBean的風格,為要被訪問的屬性提供了一套get和set方法,這兩個方法也叫做持久化類的訪問方法.記得曾經在接觸JavaBean的時候我很迷糊,總覺得提供這兩個方法,倒不如把Bean的屬性設置public,然后直接調用對象.屬性,這樣來的方便.但是后來,有一個這樣的需求,就是一個人名字可以被查看,但是不可以修改.這個時候如果用set方法的話,只需要把set方法的修飾符換為private就OK了.如果是用對象.屬性的形式調用就麻煩了.而且最重要的一個有點是JavaBean的風格可以簡化Hibernate通過JAVA反射機制來獲得持久化類的訪問方法的過程,至于JAVA的反射機制我也是了解一些皮毛.據說很深奧.有興趣的朋友可以Google一下.有一點值得注意,就是JAVA應用程序不能訪問JavaBean持久化類的private類型的get,set方法.而Hibernate沒有這個限制,可以訪問所有的級別.包括private default,protected,public.
      Java有8種基本類型:byte,short,char,int,long,float,double,boolean,還有8種與之對應的包裝類型,Byte,Short,Character,Integer,Long,Float,Double,Boolean包裝類型就是把基本類型包裝成對象的意思.基本類型于包裝類型之間可以方便的轉換,例如:
      int i = 0;
      Integer ie = new Integer(i);//基本類型轉換成包裝類型
      i = ie.intValue();//包裝類型轉化成基本類型

      注意,直接轉換也是可以的.例如i = ie; JAVA會自動把包裝類型轉換成基本類型.或者ie = i; JAVA會自動把基本類型轉換成包裝類型.在持久化類中,既可以把屬性定義為基本類型,也可以定義為包裝類型,他們對應的Hibernate映射類型int和Integer都對應int類型,這個表示不是很明顯,在用JAVA對象類型字符串舉例String,數據庫是varhcar(50),在hibernate的*.hbm.xml映射文件里一律寫為string.其實使用基本類型或者包裝類型來定義持久化類中的屬性是各有優缺點的.基本類型就是使用方便,簡單,在需要數字運算的時候直接可以運算.而包裝類型就要麻煩的先轉換成基本類型,然后在進行運算,但是包裝類型的優點在于能表達null值,每一個包裝類型的對象創建的時候默認值都是null類型的.而基本類型是不可以表達null的,它們的默認值是0.為什么要表達null值呢.因為SQL中.所有類型的數據,默認值都是null的.當進入insert的時候,沒有復值的屬性,默認值就是null,所以說JAVA的包裝類型和數據庫之間的對應關系更直接.這里建議Hibernate的OID設置為包裝類型,其他的屬性就根據業務需要和個人習慣來定吧.
      Hibernate在初始化階段會根據映射文件的信息,為所有的持久化類預定義insert語句,update語句where ID,delete語句where ID,select語句where ID,這里所說的語句就是標準的SQL增,刪,改,查.語句,參數用?代表JDBC PreparedStatement中的參數,這里就不舉例了.這些SQL語句都存放在SessionFactory的緩存中,當執行Session的save(),update(),delete(),load()方法時,將會從SessionFactory的緩存中讀取這些預定義的SQL語句,在把具體的參數值綁定到SQL語句中,這就是Hibernate的基本原理.在默認的情況下這些語句表達的是所有的字段.當然Hibernate還允許我們在映射文件里控制insert和update語句的內容.比如在映射文件中<property 元素中的update屬性設置成為false,那么這個字段,將不被包括在基本的update語句中,修改的時候,將不包括這個字段了.insert同理.dynamic動態SQL語句的配置也是很常用的.下面介紹配置SQL語句的具體屬性:
      1)<property>元素 insert屬性:設置為false,在insert語句中不包含這個字段,表示永遠不會被插入,默認true
      2)<property>元素 update屬性:設置為false,在update語句中不包含這個字段,表示永遠不會被修改,默認true
      3)<class>元素 mutable屬性:設置為false就是把所有的<property>元素的update屬性設置為了false,說明這個對象不會被更新,默認true
      4)<property>元素 dynamic-insert屬性:設置為true,表示insert對象的時候,生成動態的insert語句,如果這個字段的值是null就不會加入到insert語句當中.默認false
      5)<property>元素 dynamic-update屬性,設置為true,表示update對象的時候,生成動態的update語句,如果這個字段的值是null就不會被加入到update語句中,默認false
      6)<class>元素 dynamic-insert屬性:設置為true,表示把所有的<property>元素的dynamic-insert屬性設置為true,默認false
      7)<class>元素 dynamic-update屬性:設置為true,表示把所有的<property>元素的dynamic-update屬性設置為true,默認false

      Hibernate生成動態SQL語句的消耗的系統資源(比如CPU,內存等)是很小的,所以不會影響到系統的性能,如果表中包含N多字段,建議把dynamic-update屬性和insert屬性設置為true,這樣在插入和修改數據的時候,語句中只包括要插入或者修改的字段.可以節省SQL語句的執行時間,提高程序的運行效率.
      



我心依舊 2007-05-21 15:21 發表評論
]]>
精准平特三肖
    <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>

    <bdo id="rub96"></bdo>

      1. <track id="rub96"><div id="rub96"></div></track>
        <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>

            <nobr id="rub96"><address id="rub96"><big id="rub96"></big></address></nobr>
          1. <menuitem id="rub96"><strong id="rub96"><menu id="rub96"></menu></strong></menuitem>
            <dl id="rub96"><source id="rub96"><tr id="rub96"></tr></source></dl>
            1. <tbody id="rub96"><div id="rub96"></div></tbody>
              1. <bdo id="rub96"><optgroup id="rub96"></optgroup></bdo>
              2. <bdo id="rub96"><dfn id="rub96"><dd id="rub96"></dd></dfn></bdo>
                1. <option id="rub96"><source id="rub96"></source></option>
                2. <bdo id="rub96"></bdo>

                    <p id="rub96"><tr id="rub96"></tr></p>
                  1. <tbody id="rub96"></tbody>

                    <bdo id="rub96"></bdo>

                  2. <option id="rub96"><source id="rub96"></source></option>

                    <bdo id="rub96"><optgroup id="rub96"><dd id="rub96"></dd></optgroup></bdo>
                      <track id="rub96"></track>

                        <bdo id="rub96"></bdo>
                      1. <option id="rub96"><p id="rub96"><tr id="rub96"></tr></p></option>

                          <bdo id="rub96"></bdo>
                          1. <track id="rub96"></track>
                            1. <track id="rub96"></track>
                                  <bdo id="rub96"></bdo>
                                  <option id="rub96"></option>

                                      1. <track id="rub96"><span id="rub96"></span></track>

                                          <option id="rub96"></option>

                                          1. 
                                            
                                              <option id="rub96"><span id="rub96"></span></option>
                                              <bdo id="rub96"><address id="rub96"></address></bdo>
                                              <option id="rub96"><source id="rub96"></source></option>
                                                <nobr id="rub96"><address id="rub96"></address></nobr>
                                              1. <nobr id="rub96"><optgroup id="rub96"><big id="rub96"></big></optgroup></nobr>
                                                <track id="rub96"></track>

                                                <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>
                                                  <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>

                                                  <bdo id="rub96"></bdo>

                                                    1. <track id="rub96"><div id="rub96"></div></track>
                                                      <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>

                                                          <nobr id="rub96"><address id="rub96"><big id="rub96"></big></address></nobr>
                                                        1. <menuitem id="rub96"><strong id="rub96"><menu id="rub96"></menu></strong></menuitem>
                                                          <dl id="rub96"><source id="rub96"><tr id="rub96"></tr></source></dl>
                                                          1. <tbody id="rub96"><div id="rub96"></div></tbody>
                                                            1. <bdo id="rub96"><optgroup id="rub96"></optgroup></bdo>
                                                            2. <bdo id="rub96"><dfn id="rub96"><dd id="rub96"></dd></dfn></bdo>
                                                              1. <option id="rub96"><source id="rub96"></source></option>
                                                              2. <bdo id="rub96"></bdo>

                                                                  <p id="rub96"><tr id="rub96"></tr></p>
                                                                1. <tbody id="rub96"></tbody>

                                                                  <bdo id="rub96"></bdo>

                                                                2. <option id="rub96"><source id="rub96"></source></option>

                                                                  <bdo id="rub96"><optgroup id="rub96"><dd id="rub96"></dd></optgroup></bdo>
                                                                    <track id="rub96"></track>

                                                                      <bdo id="rub96"></bdo>
                                                                    1. <option id="rub96"><p id="rub96"><tr id="rub96"></tr></p></option>

                                                                        <bdo id="rub96"></bdo>
                                                                        1. <track id="rub96"></track>
                                                                          1. <track id="rub96"></track>
                                                                                <bdo id="rub96"></bdo>
                                                                                <option id="rub96"></option>

                                                                                    1. <track id="rub96"><span id="rub96"></span></track>

                                                                                        <option id="rub96"></option>

                                                                                        1. 
                                                                                          
                                                                                            <option id="rub96"><span id="rub96"></span></option>
                                                                                            <bdo id="rub96"><address id="rub96"></address></bdo>
                                                                                            <option id="rub96"><source id="rub96"></source></option>
                                                                                              <nobr id="rub96"><address id="rub96"></address></nobr>
                                                                                            1. <nobr id="rub96"><optgroup id="rub96"><big id="rub96"></big></optgroup></nobr>
                                                                                              <track id="rub96"></track>

                                                                                              <nobr id="rub96"><optgroup id="rub96"></optgroup></nobr>
                                                                                              1. 四川时时说明 中网内蒙古时时 甘肃快三开奖结果今天 福建时时11选五结果查询结果 香港惠澤社群官方网站 通比牛牛几个赢家 江西时时闹剧 天津快乐十分300期走势图 江苏快3版本下载 ub8平台登录 时时老玩家的经验 山西福彩十分钟 湖北快三豹子最长多少期 玩极速时时输了精光 足球即是揵报比分 快乐时时走势图