学习SSH框架

1.SSH框架的认知

  在做相关的java的网页的开发制作时,良好的层次分解是十分有比要的,所以我们在云涌第三方的框架之下来简化还有名了我们相关的网站的开发。

  SSH框架实则为Struct + spring + hibernate 的三个组成的,其中struct,专注与前台的相关的请求的所对应的ActionForm还有其相关跳转的Action来处理得到相关的JSP页面,从而来更新或是条状到相关用户的请求的服务页面,或是信息页面。而Hibernate的作用是体现在数据的持久化的层次中,我们对于页面,通过其特定的方式来对相关程序的数据惊醒I/O的持久化操作。在其次是相关spring的应用,是对与中间层次的相关的控制,处理相关业务的数据的依赖注入问题,还有就是融合其他的联大框架来实现相关程序的层次化的结构。

  2.struct框架的使用

  1. 在web.xml中进行配置,相关配置如下:
    1. <filter>
    2. <filter-name>SSH</filter-name>
    3. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    4. </filter>
    5. <filter-mapping>
    6. <filter-name>SSH</filter-name>
    7. <url-pattern>/*</url-pattern>
    8. </filter-mapping>
  2. Struct.xml的相关配置如下
    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <!DOCTYPE struts PUBLIC
    3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    4. "http://struts.apache.org/dtds/struts-2.0.dtd">
    5. <struts>
    6. <includefile="struts-default.xml"/>
    7. <packagename="ynwi"extends="struts-default">
    8. <actionname="register"class="com.ynwi.ssh.action.RegisterAction">
    9. <resultname="input">/Register.jsp</result>
    10. <resultname="success">/Success.jsp</result>
    11. <resultname="error">/Fail.jsp</result>
    12. </action>
    13. </package>
    14. </struts>
  3. 其上两处的配置的做用时。当在browser中发出相关的请求时候,Struct会把相关的请求转到Struct的特定的filter中去,然后把数据映射到在struct.xml中所示的ActionForm中去,然后在更具配置吧,数据还有其他的相关的参数转交给相关的Action来做业务的处理,软后在更具结果进行跳转的。所以我们在Struct.xml中的相关的配置,实际上就是相关的请求所对应要使用到的ActionForm还有就是Action和相关跳转页面的配置。
  4. 程序的书写代码如下:
    1. packagecom.ynwi.ssh.beans;
    2. publicclassUserForm {
    3. privateString username;
    4. privateString password;
    5. privateintgender;
    6. publicString getUsername() {
    7. returnusername;
    8. }
    9. publicvoidsetUsername(String username) {
    10. this.username = username;
    11. }
    12. publicString getPassword() {
    13. returnpassword;
    14. }
    15. publicvoidsetPassword(String password) {
    16. this.password = password;
    17. }
    18. publicintgetGender() {
    19. returngender;
    20. }
    21. publicvoidsetGender(intgender) {
    22. this.gender = gender;
    23. }
    24. } //相关的ActionForm类的书写范例。
  5. 处理业务的书写如下:
    1. packagecom.ynwi.ssh.action;
    2. importcom.opensymphony.xwork2.ActionSupport;
    3. importcom.ynwi.ssh.beans.UserForm;
    4. importcom.ynwi.ssh.service.UserManager;
    5. importcom.ynwi.ssh.serviceImpl.UserManagerImpl;
    6. publicclassRegisterAction extendsActionSupport {
    7. privatestaticfinallongserialVersionUID = 1L;
    8. privateUserForm user;
    9. privateUserManager userManager;
    10. publicUserForm getUser() {
    11. returnuser;
    12. }
    13. publicvoidsetUser(UserForm user) {
    14. this.user = user;
    15. }
    16. publicUserManager getUserManager() {
    17. returnuserManager;
    18. }
    19. publicvoidsetUserManager(UserManager userManager) {
    20. this.userManager = userManager;
    21. }
    22. publicString execute() {
    23. try{
    24. this.setUserManager(newUserManagerImpl());
    25. userManager.regUser(user);
    26. returnSUCCESS;
    27. } catch(Exception e) {
    28. e.printStackTrace();
    29. returnERROR;
    30. }
    31. }
    32. } //相关的Action的书写范例。
  6. 以上便是struct的书写的范例。Struct的其原理可查询struct的官网站,或者是相关的文档。

  3.Hibernate的使用

  1. hibernate的相关的配置如下:
    1. <?xmlversion='1.0'encoding='utf-8'?>
    2. <!DOCTYPE hibernate-configuration PUBLIC
    3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    4. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    5. <hibernate-configuration>
    6. <session-factory>
    7. <!-- Database connection settings -->
    8. <propertyname="connection.driver_class">com.mysql.jdbc.Driver</property>
    9. <propertyname="connection.url">jdbc:mysql://localhost:3306/project</property>
    10. <propertyname="connection.username">root</property>
    11. <propertyname="connection.password">root</property>
    12. <!-- JDBC connection pool (use the built-in) -->
    13. <!-- <property name="connection.pool_size">1</property> -->
    14. <!-- SQL dialect -->
    15. <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
    16. <!-- Enable Hibernate's automatic session context management -->
    17. <!-- <property name="current_session_context_class">thread</property> -->
    18. <!-- Disable the second-level cache -->
    19. <!-- <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property> -->
    20. <!-- Echo all executed SQL to stdout -->
    21. <propertyname="show_sql">true</property>
    22. <!-- Drop and re-create the database schema on startup -->
    23. <!-- <property name="hbm2ddl.auto">update</property> -->
    24. <mappingresource="com/ynwi/ssh/beans/User.hbm.xml"/>
    25. </session-factory>
    26. </hibernate-configuration>
    27. //hibernate-configuration的相关的配置实际上就是配置县官的Hibernate的相关数据库ide链接用户名还有密码。同时还有一些相关的设置的问题。还有就是Mapping的配置(对象性的数据到关系型数据映射,例子见2)
  2. mapping的配置:
    1. <?xmlversion="1.0"encoding='UTF-8'?>
    2. <!DOCTYPE hibernate-mapping PUBLIC
    3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
    5. <hibernate-mappingpackage="com.ynwi.ssh.beans">
    6. <classname="User"table="user">
    7. <idname="userId"column="userId">
    8. <generatorclass="native"></generator>
    9. </id>
    10. <propertyname="username"column="userName"type="java.lang.String"
    11. not-null="true"length="16"></property>
    12. <propertyname="password"column="password"type="java.lang.String"
    13. not-null="true"length="16"/>
    14. <propertyname="gender"column="gender"type="java.lang.Integer"length="1"/>
    15. </class>
    16. </hibernate-mapping>
    17. //其中ID是变种对应的主键,而其他的为元素的应用。
    18. //代码<generator class="native"></generator>说明将根据本地数据库的设置来创建userId,如MySQL中将表user的userId设置为自动增长,则在保存记录是,userId将自动增长。对于需要在程序中指定主键的值,则将generator的class属性设置为assigned。
  3. 相关的代码书写如下:
    1. packagecom.ynwi.ssh.dao;
    2. importorg.hibernate.HibernateException;
    3. importorg.hibernate.Session;
    4. publicinterfaceBaseDao {
    5. publicvoidsaveObject(Object obj) throwsHibernateException;
    6. publicSession getSession();
    7. publicvoidsetSession(Session session);
    8. }
    9. //数据持久化曾的相关的接口。
    1. packagecom.ynwi.ssh.daoImpl;
    2. importorg.hibernate.HibernateException;
    3. importorg.hibernate.Session;
    4. importcom.ynwi.ssh.dao.BaseDao;
    5. publicclassUserDao implementsBaseDao {
    6. privateSession session;
    7. @Override
    8. publicSession getSession() {
    9. returnsession;
    10. }
    11. @Override
    12. publicvoidsetSession(Session session) {
    13. this.session = session;
    14. }
    15. @Override
    16. publicvoidsaveObject(Object obj) throwsHibernateException {
    17. session.save(obj);
    18. }
    19. }
    20. //数据持久层的相关的实现。
  1. packagecom.ynwi.ssh.daoImpl;
  2. importorg.hibernate.HibernateException;
  3. importorg.hibernate.Session;
  4. importorg.hibernate.SessionFactory;
  5. importorg.hibernate.cfg.Configuration;
  6. importorg.hibernate.service.ServiceRegistry;
  7. importorg.hibernate.service.ServiceRegistryBuilder;
  8. publicclassHibernateSessionFactory {
  9. privatestaticfinalString CFG_FILE_LOCATION = "/Hibernate.cfg.xml";
  10. privatestaticfinalThreadLocal<Session> threadLocal = newThreadLocal<Session>();
  11. privatestaticfinalConfiguration cfg = newConfiguration()
  12. .configure(CFG_FILE_LOCATION);
  13. privatestaticServiceRegistryBuilder builder = newServiceRegistryBuilder()
  14. .applySettings(cfg.getProperties());
  15. privatestaticServiceRegistry registry;
  16. privatestaticSessionFactory sessionFactory;
  17. publicstaticSession currentSession() throwsHibernateException {
  18. Session session = threadLocal.get();
  19. if(session == null|| session.isOpen() == false) {
  20. if(sessionFactory == null) {
  21. try{
  22. registry = builder.buildServiceRegistry();
  23. sessionFactory = cfg.buildSessionFactory(registry);
  24. } catch(Exception e) {
  25. e.printStackTrace();
  26. }
  27. }
  28. session = sessionFactory.openSession();
  29. threadLocal.set(session);
  30. }
  31. returnsession;
  32. }
  33. publicstaticvoidcloseSession() throwsHibernateException {
  34. Session session = threadLocal.get();
  35. threadLocal.set(null);
  36. if(session != null) {
  37. session.close();
  38. }
  39. }
  40. }
  41. //工厂类SessionFactory的内容。(这是使用Hibernate4时候的SessionFactory,Hibernate3时候sessionFactory的创建估计会不一样,请自行查阅。
  1. packagecom.ynwi.ssh.serviceImpl;
  2. importorg.hibernate.HibernateException;
  3. importorg.hibernate.Session;
  4. importorg.hibernate.Transaction;
  5. importcom.ynwi.ssh.beans.User;
  6. importcom.ynwi.ssh.dao.BaseDao;
  7. importcom.ynwi.ssh.daoImpl.HibernateSessionFactory;
  8. importcom.ynwi.ssh.daoImpl.UserDao;
  9. importcom.ynwi.ssh.forms.UserForm;
  10. importcom.ynwi.ssh.service.UserManager;
  11. publicclassUserManagerImpl implementsUserManager {
  12. privateBaseDao dao;
  13. privateSession session;
  14. publicUserManagerImpl() {
  15. dao = newUserDao();
  16. }
  17. @Override
  18. publicvoidregUser(UserForm userForm) throwsHibernateException {
  19. session = HibernateSessionFactory.currentSession();
  20. dao.setSession(session);
  21. // 获取事务
  22. Transaction ts = session.beginTransaction();
  23. // 构造User对象
  24. User user = newUser();
  25. user.setUsername(userForm.getUsername());
  26. user.setPassword(userForm.getPassword());
  27. user.setGender(userForm.getGender());
  28. // 保存User对象
  29. dao.saveObject(user);
  30. // 提交事务
  31. ts.commit();
  32. // 关闭Session
  33. HibernateSessionFactory.closeSession();
  34. }
  35. }
  36. //相关的业务逻辑。

  4.Hibernate的总结:

  Hibernate实际上是在configuration方法的读取之下,得到相关的变量然后在通过此变量得到相关的sessionfactory类,通过SessionFactory类来读到会话类(Session)然后Session中的系列方法类进行数据库中的对应增,删,改,查的操作。当然session还可以开启事物的相关的操作。

  4.Spring整合:

  1. ApplicationContext.xml相关配置:
    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <beansxmlns="http://www.springframework.org/schema/beans"
    3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. xsi:schemaLocation="http://www.springframework.org/schema/beans
    5. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    6. <!-- 定义数据源的信息 -->
    7. <beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"
    8. destroy-method="close">
    9. <propertyname="driverClass">
    10. <value>com.mysql.jdbc.Driver</value>
    11. </property>
    12. <propertyname="jdbcUrl">
    13. <value>jdbc:mysql://localhost/project</value>
    14. </property>
    15. <propertyname="user">
    16. <value>root</value>
    17. </property>
    18. <propertyname="password">
    19. <value>root</value>
    20. </property>
    21. <propertyname="maxPoolSize">
    22. <value>80</value>
    23. </property>
    24. <propertyname="minPoolSize">
    25. <value>1</value>
    26. </property>
    27. <propertyname="initialPoolSize">
    28. <value>1</value>
    29. </property>
    30. <propertyname="maxIdleTime">
    31. <value>20</value>
    32. </property>
    33. </bean>
    34. <!--定义Hibernate的SessionFactory -->
    35. <!-- SessionFactory使用的数据源为上面的数据源 -->
    36. <!-- 指定了Hibernate的映射文件和配置信息 -->
    37. <beanid="sessionFactory"
    38. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    39. <propertyname="dataSource">
    40. <reflocal="dataSource"/>
    41. </property>
    42. <propertyname="mappingResources">
    43. <list>
    44. <value>com/ynwi/ssh/beans/User.hbm.xml</value>
    45. </list>
    46. </property>
    47. <propertyname="hibernateProperties">
    48. <props>
    49. <propkey="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    50. <propkey="show_sql">true</prop>
    51. <propkey="hibernate.jdbc.batch_size">20</prop>
    52. </props>
    53. </property>
    54. </bean>
    55. <beanid="transactionManager"
    56. class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    57. <propertyname="sessionFactory"ref="sessionFactory"/>
    58. </bean>
    59. <beanid="baseDao"class="com.ynwi.ssh.daoImpl.UserDao">
    60. <propertyname="sessionFactory">
    61. <refbean="sessionFactory"/>
    62. </property>
    63. </bean>
    64. <!--用户注册业务逻辑类 -->
    65. <beanid="userManager"class="com.ynwi.ssh.serviceImpl.UserManagerImpl">
    66. <propertyname="dao">
    67. <refbean="baseDao"/>
    68. </property>
    69. </bean>
    70. <!-- 用户注册的Action -->
    71. <beanid="regAction"class="com.ynwi.ssh.action.RegisterAction">
    72. <propertyname="userManager">
    73. <refbean="userManager"/>
    74. </property>
    75. </bean>
    76. <!-- more bean definitions go here -->
    77. </beans>
    78. //对于用户中的业务逻辑还有持久化操作的逻辑的相关类,我们放到spring的相关的容器中进行统一的管理。
  2. 以上相关的修改结果如下(相对于之前的类来说):BaseDao.java

      [java]view plain copy print ?

    1. packagecom.ynwi.ssh.dao;
    2. importorg.hibernate.HibernateException;
    3. publicinterfaceBaseDao {
    4. publicvoidsaveObject(Object obj) throwsHibernateException;
    5. }

      UserDao.java

      [java]view plain copy print ?

    1. packagecom.ynwi.ssh.daoImpl;
    2. importorg.hibernate.HibernateException;
    3. importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;
    4. importcom.ynwi.ssh.dao.BaseDao;
    5. publicclassUserDao extendsHibernateDaoSupport implementsBaseDao {
    6. @Override
    7. publicvoidsaveObject(Object obj) throwsHibernateException {
    8. getHibernateTemplate().save(obj);
    9. }
    10. }

      //getHibernateTemplate():HibernateTemplate 提供非常多的常用方法来完成基本的操作,比如通常的增加、删除、修改、查询等操作,Spring 2.0更增加对命名SQL查询的支持,也增加对分页的支持。大部分情况下,使用Hibernate的常规用法,就可完成大多数DAO对象的CRUD操作。 下面是HibernateTemplate的常用方法简介:

      q void delete(Object entity):删除指定持久化实例

  3. q deleteAll(Collection entities):删除集合内全部持久化类实例

  4. q find(String queryString):根据HQL查询字符串来返回实例集合

  5. q findByNamedQuery(String queryName):根据命名查询返回实例集合

  6. q get(Class entityClass, Serializable id):根据主键加载特定持久化类的实例

  7. q save(Object entity):保存新的实例

  8. q saveOrUpdate(Object entity):根据实例状态,选择保存或者更新

  9. q update(Object entity):更新实例的状态,要求entity是持久状态

  10. q setMaxResults(int maxResults):设置分页的大小·····························································································································································在dao层用到getSession()方法来操作数据库记录,但是他还有个方法getHibernateTemplate(),这两个方法究竟有什么区别呢?

      1.使用getSession()方法你只要继承 sessionFactory,而使用getHibernateTemplate()方法必须继承HibernateDaoSupport当然包括 sessionFactory,这点区别都不是特别重要的,下面这些区别就很重要了

      2.getSession()方法是没有经过spring包装 的,spring会把最原始的session给你,在使用完之后必须自己调用相应的close方法,而且也不会对声明式事务进行相应的管理,一旦没有及时 关闭连接,就会导致数据库连接池的连接数溢出,getHibernateTemplate()方法是经过spring封装的,例如添加相应的声明式事务管 理,由spring管理相应的连接。

      在实际的使用过程中发现的确getHibernateTemplate()比getSession()方法要好很多,但是有些方法在getHibernateTemplate()并没有提供,这时我们用HibernateCallback 回调的方法管理数据库.

      例如如下代码:

      /** * 使用 hql 语句进行操作

  11. * @param hql HSQL 查询语句(使用回调函数访问外部变量,必须是final的)

  12. * @param offset 开始取数据的下标

  13. * @param length 读取数据记录数

  14. * @return List 结果集

  15. */

  16. public List getListForPage ( final String hql , final int offset , final int length ) {

      List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {

  17. public Object doInHibernate ( Session session ) throws HibernateException, SQLException {

  18. Query query = session.createQuery ( hql ) ; query.setFirstResult ( offset ) ; query.setMaxResults ( length ) ; List list = query.list ( ) ; return list ;

  19. }

  20. }) ;

  21. return list ;}

    • 修改后的业务逻辑实现类UserManagerImpl的内容。

      [java]view plain copy print ?

    1. packagecom.ynwi.ssh.serviceImpl;
    2. importorg.hibernate.HibernateException;
    3. importorg.springframework.beans.BeanUtils;
    4. importcom.ynwi.ssh.beans.User;
    5. importcom.ynwi.ssh.dao.BaseDao;
    6. importcom.ynwi.ssh.forms.UserForm;
    7. importcom.ynwi.ssh.service.UserManager;
    8. publicclassUserManagerImpl implementsUserManager {
    9. privateBaseDao dao;
    10. publicvoidsetDao(BaseDao dao) {
    11. this.dao = dao;
    12. }
    13. @Override
    14. publicvoidregUser(UserForm userForm) throwsHibernateException {
    15. User user = newUser();
    16. BeanUtils.copyProperties(userForm, user);
    17. dao.saveObject(user);
    18. }
    19. }
    • 修改后的用户注册Action类RegisterAction的内容。

      [java]view plain copy print ?

    1. packagecom.ynwi.ssh.action;
    2. importcom.opensymphony.xwork2.ActionSupport;
    3. importcom.ynwi.ssh.forms.UserForm;
    4. importcom.ynwi.ssh.service.UserManager;
    5. publicclassRegisterAction extendsActionSupport {
    6. privatestaticfinallongserialVersionUID = 1L;
    7. privateUserForm user;
    8. privateUserManager userManager;
    9. publicUserForm getUser() {
    10. returnuser;
    11. }
    12. publicvoidsetUser(UserForm user) {
    13. this.user = user;
    14. }
    15. publicvoidsetUserManager(UserManager userManager) {
    16. this.userManager = userManager;
    17. }
    18. publicString execute() {
    19. try{
    20. userManager.regUser(user);
    21. returnSUCCESS;
    22. } catch(Exception e) {
    23. e.printStackTrace();
    24. returnERROR;
    25. }
    26. }
    27. }
    • 修改后的web.xml的内容。

      [html]view plain copy print ?

    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <web-appid="WebApp_9"version="2.4"xmlns="http://java.sun.com/xml/ns/j2ee"
    3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    5. <display-name>SSH Project</display-name>
    6. <filter>
    7. <filter-name>SSH</filter-name>
    8. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    9. </filter>
    10. <filter-mapping>
    11. <filter-name>SSH</filter-name>
    12. <url-pattern>/*</url-pattern>
    13. </filter-mapping>
    14. <listener>
    15. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    16. </listener>
    17. <welcome-file-list>
    18. <welcome-file>index.html</welcome-file>
    19. </welcome-file-list>
    20. </web-app>
    • 修改后的Struts配置文件struts.xml的内容。

      [html]view plain copy print ?

    1. <?xmlversion="1.0"encoding="UTF-8"?>
    2. <!DOCTYPE struts PUBLIC
    3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    4. "http://struts.apache.org/dtds/struts-2.0.dtd">
    5. <struts>
    6. <includefile="struts-default.xml"/>
    7. <packagename="ynwi"extends="struts-default">
    8. <actionname="register"class="regAction">
    9. <resultname="input">/Register.jsp</result>
    10. <resultname="success">/Success.jsp</result>
    11. <resultname="error">/Fail.jsp</result>
    12. </action>
    13. </package>
    14. </struts>

  5.总结

  有待改善。

技术分享:www.kaige123.com

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。
package com.erp.util;   import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.io.StringWriter; import java.net.HttpURLC
如题,大家可以参考参考 package lesson12;import java.util.ArrayList;import java.util.List;import java.util.Scanner;public class lesson12 {/** * 输入两个正整数m和n,求其最大公约数和最小公倍数 */public static void main(String args[]) {// ListInteger list=new ArrayList();Scanner scan = new S
private File file; private String fileFileName; private String picture; InputStream is = new FileInputStream(file); //引入一个IO流的输入流String root = ServletActionContext.getRequest() .getRealPath("/bookpicture"); //通过REQUEST来得到相对地址,并在后面加上/bookpictureFile f = ne

java-选择排序 - 2016-09-15 14:09:03

public class ChoiceSort {//选择排序public static void choiceSort(int[] a){int i,j,temp;int min=0;for(i=0; ia.length;i++){min=i; //将当前下标定义为最小值下标for(j=i+1;ja.length;j++){if(a[min]a[j]){/* 如果有小于当前最小值的关键字 */ min=j;/* 将此关键字的下标赋值给min */ }}if(i!=min){/* 若min不等于i,说明找

java-插入排序 - 2016-09-15 14:09:03

1、基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。 /** * 插入排序 * * 从第一个元素开始,该元素可以认为已经被排序 * 取出下一个元素,在已经排序的元素序列中从后向前扫描 * 如果该元素(已排序)大于新元素,将该元素移到下一位置 * 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置 * 将新元素插入到该位置中 * 重复步骤2 * @param numbers 待排序数组 */ public stati

JAVA和C++区别 - 2016-09-15 14:09:03

Java和C++都是面向对象语言。也就是说,它们都能够实现面向对象思想(封装,继乘,多态)。而由于c++为了照顾大量的C语言使用者, 而兼容了C,使得自身仅仅成为了带类的C语言,多多少少影响了其面向对象的彻底性!JAVA则是完全的面向对象语言,它句法更清晰,规模更小,更易学。它是在对多种程序设计语言进行了深入细致研究的基础上,据弃了其他语言的不足之处,从根本上解决了c++的固有缺陷。 Java和c++的相似之处多于不同之处,但两种语言问几处主要的不同使得Java更容易学习,兄弟连JavaEE培训  ,并且编

配置文件的读取与写入 - 2016-09-15 14:09:03

读取配置文件: public static void main(String[] args) {Properties prop = new Properties();try {InputStream in = new BufferedInputStream(new FileInputStream("src/test/test.properties"));// 读取属性文件a.propertiesprop.load(in); // /加载属性列表System.out.println(prop.getPrope

android eclipse错误集合 - 2016-09-15 14:09:03

   1.  devices.xml 错误      [2016-09-14 15:20:11 - Android SDK] Error when loading the SDK:   Error: Error parsing D:\Users\shouzhuo3\AppData\Local\Android\sdk\system-images\android-22\android-wear\x86\devices.xml cvc-complex-type.2.4.d: 发现了以元素 'd:skin' 开头
这篇文章已经是有数年“网龄”的老文,不过在今天看来仍然经典。如何学习Java?本篇文章可以说也是面对编程初学者的一篇指导文章,其中对于如何学习Java的步骤的介绍,很多也适用于开发领域其他技能的学习。 【在原先《学好Java之我见》的基础上重新整理而成】 Java - 近10年来计算机软件发展过程中的传奇,其在众多开发者心中的地位就如“屠龙刀”、“倚天剑”。 我去年加入了一个java培训班,好在人品比较不错,没有被坑,学到了很多东西,也让我少走了很多弯路,Java是个平台,我只想说说我对学好Java的一点
今年我一直在思考web开发里的前后端分离的问题,到了现在也颇有点心得了,随着这个问题的深入,再加以现在公司很多web项目的控制层的技术框架由struts2迁移到springMVC,我突然有了一个新的疑问无法得到正确的解释,为什么我们现在做java的web开发,会选择struts2或者springMVC这样的框架,而不是使用servlet加jsp这样的技术呢?特别是现在我们web的前端页面都是使用velocity这样的模板语言进行开发,抛弃了jsp,这样的选择又会给我们java的web开发带来什么样的好处,延