精华内容
下载资源
问答
  • ssh入门demo

    2016-01-27 14:31:18
    很简单的一个例子,在网上找的一个资源,里面有ppt讲解,非常的清晰
  • SSH入门整合案例

    2012-07-24 22:09:01
    1.简单的ssh集成配置开发,所有源代码全部开放, 包括所有包。都是经过我自己敲了调试的。 2.仅仅适合初学者入门,第一次发请多多指教,有问题请与我联系。 3,数据库为mysql5.5,仅仅对一张表的crud操作。
  • ├─动力节点-java教程-SSH前言视频 │ 北京动力节点SSH前言-001-系统架构-三层架构.mp4 │ 北京动力节点SSH前言-002-系统架构-MVC.mp4 │ 北京动力节点SSH前言-003-系统架构-三层架构与MVC.mp4 │ 北京动力节点SSH...
  • 较好的ssh入门小例子

    2013-07-27 15:47:45
    较好的ssh入门小例子
  • SSH入门及使用教程ppt.zip
  • 初学SSH入门实例

    2011-11-08 16:14:40
    对于学习SSH框架简单案例,易学、易用、易懂,更好的为初学者打好基础,只要按照案例步骤就可以学会简单使用。
  • SSH入门

    2016-06-19 21:20:39
    ssh(struts+spring+hibernate)究竟是怎么一回事?是一种规范。 先别管规范,我们从最基本的概念去理解它。java是对面向对象的编程语言,java里一切只有类,java项目的本质就是执行类的方法,类与类之间的调用。...
      ssh(struts+spring+hibernate)究竟是怎么一回事?是一种规范。
    

    先别管规范,我们从最基本的概念去理解它。java是对面向对象的编程语言,java里一切只有类,java项目的本质就是执行类的方法,类与类之间的调用。利用的其它资源就是文件,主要是xml配置文件,另外就是数据库。

    jsp文件实质也是一种java类,它将被编译成Servlet类文件。jsp是为了简化用户编写繁杂的Servlet类文件而设置的。web容器(也是一堆java类)负责把jsp文件转化成Servlet类文件。

    为了完成一个任务,实现一个功能,需要写许多java类,根据java类的作用不同,可以把java类分成几种,有些负责页面展示,有些负责业务处理逻辑运算,有些负责访问数据库。当然,你也可以把这些功能写在一个类里实现(呵呵,这在理论上是能实现的!),不过人们为了代码更加清晰,往往一个大功能分成许多小功能,由多个类去实现。

    上面的话大家应该不难理解,即为了完成一个大功能,要由许多类,分别完成相应专门功能。可这和框架似乎无关,框架又是怎么回事呢?所谓框架就是“由许多类,分别完成相应专门功能”的具体规范,这在多人合作开发一个大项目时尤为必要。大家试想,如果项目组成员各行其是,自己想用哪几种类实现功能就用哪几种类,会是一个什么样子,有多混乱!因此框架的定义就是:为了完成一个整体功能,对实现这个功能的java类的一种分工规范。(准确说,这是一种人为的规范划分,任何人都可编写自己的任意规范,就是一个会有多少人会用的问题了)

    struts+spring+hibernate就是这样一种规范

    struts是显示层的一种规范,侧重于处理“给用户显示的前台页面”和后台业务处理类之间的对应关系,并且负责前后台之间的数据传递。它由三种java类组件jsp、Form、Action分别实现前台页面展示、后台业务处理类、数据传递类。(所谓组件,就是对一种专门实现某种功能的java类的称呼)

    spring是业务层的一种规范,侧重于定义事务处理,提供了对各种java类的整体处理(主要包括注入处理IoC和切面编程AOP),甚至提供了对多种框架集成在一块的规范,它是一种更高层次的框架,它主要以一个外部 XML 配置文件方便地将各框架对象连接在一起,进而实现安全性服务、事务服务等。

    这里大家可能有一个疑问,spring是如何以一个外部 XML 配置文件实现的各种功能呢?这其实没有任何神秘而言,我们大家都知道,每个框架都有许多类包,这些类包就是专门实现这些事情的。这些类包是如何介入我们写的类代码或其它框架的呢?当然必须通过一定途径才能调用其它类代码,有时spring把这个细节隐藏了起来,使我们感到不可思议,细究一下,我们会发现不外通过两种方式才能调用其它类代码:一是把我们的类写在它的配置文件里,二是我们的类继承它的接口。

    hibernate是一个纯 Java 的对象关系映射和持久性框架,它允许您用 XML 配置文件把普通 Java 对象映射到关系数据库表,从而可以使用户以hibernate提供的面向对象的接口轻松操作数据库。hibernate的类包在后台还是以JDBC的方式操作数据库。

    三种技术到目前已经比较成熟,而且他们都是免费的!让我们对三者集成,与大家一起轻松、深入地进入ssh天地 
    展开全文
  • SSH入门教程

    2017-10-04 20:44:51
    本教程共有4章,以非常通俗易懂的方式,向我们介绍Struts、Spring、Hibernate三大现在比较流行的JAVA_WEB开发框架,非常适合刚刚接触的朋友快速入门。 chap01 领略清晰的MVC流程----Struts讲解技术资料.pdf chap02 ...
  • ssh入门

    千次阅读 多人点赞 2013-03-18 14:50:54
    ssh,对于java web开发新手还是一个比较陌生的名字,在此我就简单给初窥java web门径的兄弟们简单介绍这个现在相当流行的java web开发框架。     首先,何为框架?  框架是整个或部分系统的可重用设计,表现...

            ssh,对于java web开发新手还是一个比较陌生的名字,在此我就简单给初窥java web门径的兄弟们简单介绍这个现在相当流行的java web开发框架。

     

            首先,何为框架

            框架是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;或者说,框架是可被应用开发者定制的应用骨架。简而言之,框架即是为了方便我们程序员开发,减少代码量及增加代码质量的工具。

     

          那么何为ssh框架呢?

           ssh乃Spring + Struts +Hibernate,是三种框架的集成。这三种框架各有所能,集合在一起就能极大地方便我们进行java web的开发。

           Struts对Model,View和Controller都提供了对应的组件。 Spring是为了解决企业应用开发的复杂性而创建的,它使用基本的JavaBean来完成以前只可能由EJB完成的事情。 Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,可以应用在任何使用JDBC的场合,可以在Servlet/JSP的Web应用中使用,完成数据持久化的重任。

           

          第一个S——Struts

           
    1.Struts框架结构  如右图:
    Struts对Model,View和Controller都提供了对应的组件。
    在右图中,ActionServlet,这个类是Struts的核心控制器,负责拦截来自用户的请求。
    Action,这个类通常由用户提供,该控制器负责接收来自ActionServlet的请求,并根据该请求调用模型的业务逻辑方法处理请求,并将处理结果返回给JSP页面显示。
    2.Model部分 由ActionForm和JavaBean组成,其中ActionForm用于封装用户的请求参数,封装成ActionForm对象,该对象被ActionServlet转发给Action,Action根据ActionForm里面的请求参数处理用户的请求。
    JavaBean则封装了底层的业务逻辑,包括数据库访问等。
    3.View部分 该部分采用JSP实现。
    Struts提供了丰富的标签库,通过标签库可以减少脚本的使用,自定义的标签库可以实现与Model的有效交互,并增加了现实功能。对应上图的JSP部分。
    4.Controller组件 Controller组件有两个部分组成——系统核心控制器,业务逻辑控制器。
    系统核心控制器,对应上图的ActionServlet。该控制器由Struts框架提供,继承HttpServlet类,因此可以配置成标注的Servlet。该控制器负责拦截所有的HTTP请求,然后根据用户请求决定是否要转给业务逻辑控制器。
    业务逻辑控制器,负责处理用户请求,本身不具备处理能力,而是调用Model来完成处理。对应Action部分。
     
    第二个S——Spring
    1.简介 
    ◆目的:解决企业应用开发的复杂性
    ◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
    ◆范围:任何Java应用
    简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
    2.轻量 从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。
    3.控制反转 Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
    4.面向切面 Spring提供了面向切面的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。
    5.容器 Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。
    6.框架 Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。
    所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
     
    Hibernate
    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
    Hibernate的核心接口一共有5个,分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。
     
    第一次和ssh并肩作战
    说了一堆理论,我们试着用通过实际的例子来看看这个ssh究竟有什么神奇之处。
    注:我们只是看看ssh的处理逻辑,未详解其配置,关于ssh的具体配置放到下一篇博文(*^__^*)
     
    新建一个web project,新建后的目录结构同时包含了新建文件夹page用于放jsp文件,和源文件夹test用于放junit测试文件。同时将用到的包,包括struts,hibernate,spring都导入到lib目录下。

      
    创建持久层O/R mapping

       1. 在src/com.jandar.model下用hibernate插件从数据库导出app_user的.hbm.xml文件改名为User.hbm.xml

    <?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
       "-//Hibernate/Hibernate Mapping DTD//EN"
       "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
    <hibernate-mapping package="com.jandar.model">
    <class name="User" table="APP_USER">
      <id
       column="ID"
       name="id"
       type="integer"
      >

       <generator class="assigned" />

      </id>

      <property
        column="LASTNAME"
        length="10"
        name="lastname"
        not-null="false"
        type="string"
      />

      <property
        column="FIRSTNAME"
        length="10"
        name="firstname"
        not-null="true"
        type="string"
      />

    </class>
    </hibernate-mapping>

       2. 通过hibernate synchronizer->synchronizer file生成User.java文件,User对象对应于数据库中的app_user表

       注:在eclipse下自动生成的对象文件不完全相同,相同的是每个对象文件必须实现Serializable接口,必需又toString和hashCode方法;

    import java.io.Serializable;
    import org.apache.commons.lang.builder.EqualsBuilder;
    import org.apache.commons.lang.builder.HashCodeBuilder;
    import org.apache.commons.lang.builder.ToStringBuilder;
    import org.apache.commons.lang.builder.ToStringStyle;

    public class BaseObject implements Serializable {
      public String toString() {
       return ToStringBuilder.reflectionToString(this,
       ToStringStyle.MULTI_LINE_STYLE);
      }

      public boolean equals(Object o) {
       return EqualsBuilder.reflectionEquals(this, o);
      }

      public int hashCode() {
       return HashCodeBuilder.reflectionHashCode(this);
      }
    }

    public class User extends BaseObject {
      private Long id;
      private String firstName;
      private String lastName;

      /**
      * @return Returns the id.
      */

      public Long getId() {
       return id;
      }

      /**
       * @param id The id to set.
      */

      public void setId(Long id) {
       this.id = id;
      }

      /**
      * @return Returns the firstName.
      */

      public String getFirstName() {
       return firstName;
      }

      /**
       * @param firstName The firstName to set.
      */

      public void setFirstName(String firstName) {
       this.firstName = firstName;
      }

      /**
      * @return Returns the lastName.
      */

      public String getLastName() {
       return lastName;
      }

      /**
      * @param lastName The lastName to set.
      */

      public void setLastName(String lastName) {
       this.lastName = lastName;
      }
    }

    创建DAO访问对象

       1. 在src/com.jandar.service.dao新建IDAO.java接口,所有的DAO都继承该接口

    package com.jandar.services.dao;

    public interface IDAO

       2. 在src/com.jandar.service.dao下新建IUserDAO.java接口

    public interface IUserDAO extends DAO {
      List getUsers();
      User getUser(Integer userid);
      void saveUser(User user);
      void removeUser(Integer id);
    }

       该接口提供了访问对象的方法,

       3. 在src/com.jandar.service.dao.hibernate下新建UserDAOHiberante.java

    import java.util.List;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.orm.hibernate.support.HibernateDaoSupport;
    import com.jandar.model.User;
    import com.jandar.service.dao.IUserDAO;

    public class UserDaoHibernate extends HibernateDaoSupport implements IUserDAO {

      private Log log=LogFactory.getLog(UserDaoHibernate.class);
      /* (非 Javadoc)
      * @see com.jandar.dao.IUserDAO#getUsers()
      */

      public List getUsers() {
       return getHibernateTemplate().find("from User");
      }

      /* (非 Javadoc)
      * @see com.jandar.dao.IUserDAO#getUser(java.lang.Long)
      */

      public User getUser(Integer id) {
       // TODO 自动生成方法存根
       return (User) getHibernateTemplate().get(User.class,id);
      }

      /* (非 Javadoc)
      * @see com.jandar.dao.IUserDAO#saveUser(com.jandar.model.User)
      */

      public void saveUser(User user) {
       log.debug("xxxxxxx");
       System.out.println("yyyy");
       getHibernateTemplate().saveOrUpdate(user);
       if(log.isDebugEnabled())
       {
        log.debug("userId set to "+user.getId());
       }
      }

      /* (非 Javadoc)
      * @see com.jandar.dao.IUserDAO#removeUser(java.lang.Long)
      */

      public void removeUser(Integer id) {
       Object user=getHibernateTemplate().load(User.class,id);
       getHibernateTemplate().delete(user);
       if(log.isDebugEnabled()){
        log.debug("del user "+id);
       }
      }
    }

       在这个类中实现了IUserDAO接口的方法,并且继承了HibernateDAOSupport类。这个类的作用是通过hibernate访问、操作对象,进而实现对数据库的操作。

     

    希望这些能帮助对ssh还不了解的朋友对ssh有一个初步的认识,支持的话顶一个噢(*^__^*)
    展开全文
  • SSH入门笔记

    2015-05-09 09:25:02
    SSH入门笔记,非常详细的框架笔记,从框架搭建到框架使用,非常详细的给大家讲解struts1、Struts2、hibernate、spring的使用。
  • 这是一份使用 struts2+spring3+hibernate3 的整合流程,单表入门级,方便学习
  • SSH课程包是JSP的部分的3大主流框架,Struts2,Hibernate,Spring
  • SSH入门教程,适合新手学习,深入浅出掌握SSH。
  • SSH入门整合例子

    2014-06-26 23:44:14
    适合刚了解ssh基础的初级学员,很简单的一个ssh整合的框架搭配
  • SSH入门实例

    2011-10-24 11:19:57
    SSH入门实例,详细介绍的SSH三大框架的构架,以及应用,适合初学者学习,对其有很大的帮助
  • SSH是一种网络协议,用于计算机之间的加密登录。如果一个用户从本地计算机,使用SSH协议登录另一台远程计算机,我们就可以认为,这种登录是安全的,即使被中途截获,密码也不会泄露。最早的时候,互联网通信都是明文...

      SSH是一种网络协议,用于计算机之间的加密登录。如果一个用户从本地计算机,使用SSH协议登录另一台远程计算机,我们就可以认为,这种登录是安全的,即使被中途截获,密码也不会泄露。最早的时候,互联网通信都是明文通信,一旦被截获,内容就暴露无疑。1995年,芬兰学者Tatu Ylonen设计了SSH协议,将登录信息全部加密,成为互联网安全的一个基本解决方案,迅速在全世界获得推广,目前已经成为Linux系统的标准配置。

    安装

    sudo apt-get install -y openssh-server 

    配置

    vim /etc/ssh/sshd_config
    Port 22        #端口
    Protocol 2,1   #版本
    ListenAddress 0.0.0.0 #监控的IP
    PidFile /var/run/sshd.pid 
    LoginGraceTime 600
    Compression yes
    HostKey /etc/ssh/ssh_host_key
    HostKey /etc/ssh/ssh_host_rsa_key
    HostKey /etc/ssh/ssh_host_dsa_key

     

    转载于:https://www.cnblogs.com/overarching/p/7990795.html

    展开全文
  • SSH 入门架包

    2011-12-21 14:05:42
    初学者用得着的最基本的SSH框架需要的架包,可以开发一些最简单的例子程序入用户注册登录,留言本等等
  • SSH入门简单搭建例子

    千次阅读 2016-11-27 21:22:39
    SSH入门简单搭建例子 因为公司涉及项目使用SSH,为了解SSH搭建方式和运作原理,就自己搭建了一个。 采用尽量以最少的JAR包,搭建一个简单的struts2+spring+hibernate环境,希望像我这样的入门者都能理解,...

    SSH入门简单搭建例子

    因为公司涉及项目使用SSH,为了解SSH搭建方式和运作原理,就自己搭建了一个。

    采用尽量以最少的JAR包,搭建一个简单的struts2+spring+hibernate环境,希望像我这样的入门者都能理解,如果大家使用过类似的MVC模式如Microsoft MVC,就容易理解得多了。

    首先我使用的是MyEclipse 9+Tomcat 6(据说Tomcat和struts版本会有不兼容,但没遇上,不知道是不是真的)。

    我下载的是struts2.3.15.1的JAR包(已包含spring)官网下载地址:http://struts.apache.org/download.cgi#struts23151

    hibernate因为官网版本已到hibernate4,担心不兼容,所以去新浪共享下载hibernate3.3.2,下载地址http://ishare.iask.sina.com.cn/f/33704027.html

    下载完成后,开始搭建。

    第一步,使用struts2。

    导入struts所需的包:

    strust-core-xxx.jar                  xwork-core-xxx.jar              commons-io-xxx.jar

    commons-fileupload-xxx.jar      commons-lang-xxx.jar         commons-logging-xxx.jar

    freemarker-xxx.jar                   javassist-xxx.GA.jar            ognl-xxx.jar

    导入包的方式有很多,可以在Build Path里面 Add Extenal JARs添加,可以新建一个自定义的Librariy添加这些包然后再导入这个Library。我就用最简单的方式,把这些包复制到项目的WebRoot->WEB-INF->lib下面,这样项目就会自动把包导入到Referenced Libraries下面了。

    导入包后编译一下,顺利运行Tomcat,我们就可以测试一下Struts了。在src目录下新建一个struts.xml,内容如下:

    复制代码
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
    <struts>
        <!-- 需要Spring时添加 -->
        <!-- <constant name="struts.objectFactory" value="spring" />  -->
    
        <package name="default" extends="struts-default">
            <action name="login" class="com.struts2test.action.LoginAction" method="execute">
                <result name='success'>/index.jsp</result>
                <result name='login'>/login.jsp</result>
            </action>
        </package>
        
    </struts>
    复制代码

    如上面所示"default"包是Web请求到Struts会首先进入这里来寻找我们的action路径。

    项目为了支持Struts,我们还需在WebRoot -> WEB-INF下面修改web.xml,内容如下:

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
     xmlns="http://java.sun.com/xml/ns/javaee" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
     
       <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>
     
       <welcome-file-list>
            <welcome-file>index.jsp</welcome-file>
       </welcome-file-list>
    </web-app>
    复制代码

    添加的filter和filter-mapping顾名思义是过滤器,所有客户端Web请求都会首先进入这个web.xml,是WEB项目最基础的一个配置文件,其他文件都是这个xml导航过去的。传统的方式是直接使用Servlet直接导航到方法,这样项目层次很少,大家都应该知道,层次少开发容易维护就比较麻烦,层次多一些开发会麻烦但是维护则显得容易很多。Struts其实也是封装了Servlet方法罢了。

    然后就新建一个com.struts2test.action包放所有的action方法,在这个包下新建一个Class类,如struts.xml里面命名为LoginAction即可,内容如下:

    复制代码
    package com.struts2test.action;
    
    import com.opensymphony.xwork2.ActionSupport;
    
    public class LoginAction extends ActionSupport {// 该类继承了ActionSupport类。这样就可以直接使用SUCCESS,
                                                    // LOGIN等变量和重写execute等方法
    
        private String username;
        private String password;
        
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
        
        @Override
        public String execute() throws Exception {
            if (username.equals("admin") && password.equals("123"))//返回SUCCESS;否则,返回LOGIN
                return SUCCESS;
            return LOGIN;
        }
    }
    复制代码

    上面所示,我们需要为username和password一个setter和getter,这样页面传值这里将可以接收并给他们赋值,可以推测,页面传值也是注入进来的。

    有了这个方法,我们就可以根据login.jsp提交的username和password来判断进入index主页了!

    index主页内容就随便,login.jsp也很简单,内容如下:

    复制代码
    <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
    <%
    String
    path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <base href="<%=basePath%>"> <title>My JSP 'login.jsp' starting page</title> <meta http-equiv="pragma" content="no-cache"> <meta http-equiv="cache-control" content="no-cache"> <meta http-equiv="expires" content="0"> <meta http-equiv="keywords" content="keyword1,keyword2,keyword3"> <meta http-equiv="description" content="This is my page"> <!-- <link rel="stylesheet" type="text/css" href="styles.css"> --> </head> <body> <form method="post" action="login"> 登录名:<input name='username' type="text" /><br/> 密码:<input name ='password' type="password" /><br/> <button type="submit" style="width: 70px; height: 20px;">确定</button> </form> </body> </html>
    复制代码

    做过基本的HTML传值的应该都知道input的name属性是用来传值的,所以应该和我们上面LoginAction方法的username和password名字一样,不然传值会失败的。

    万事俱备,发布到Tomcat上编译运行。通过 http://localhost:8080/项目名/login.jsp 就能访问我们的网站了。输入admin/123进入index.jsp,就是成功了!

    第二步,在struts基础上使用spring。

    导入spring所需要的包:

    strus2t-spring-plugin-xxx.jar        spring-core-xxx.jar         spring-context-xxx.jar

    spring-bean-xxx.jar                     spring-web-xxx.jar           spring-asm-xxx.jar             spring-expression-xxx.jar

    使用spring主要是依赖注入和切面编程,这里就利用spring注入username和password给LoginAction试试,这样无论界面输入什么都无所谓,程序都使用我注入的username和password了。

    为了使Struts支持Spring(当Struts寻找到action的时候同时用Spring注入bean),要在Struts.xml添加如下语句:

    <constant name="struts.objectFactory" value="spring" />

    前面已经写了,取消注释即可。

    然后在src目录下新建applicationContext.xml,内容如下:

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
               http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
        
        <bean id="LoginAction" class="com.struts2test.action.LoginAction">
            <property name="username" value="admin">
            </property>
            <property name="password" value="123">
            </property>
        </bean>
    
    </beans>
    复制代码

    这样之后,重新部署Tomcat启动,我们在login.jsp上面无论输入什么,我们都可以跳转到index.jsp。因为spring已经帮我们注入了一个固定的值。

    这里可以看到,我们使用多少个bean就需要在这里配置多少个,这样其实就显得麻烦,和传统的配置Servlet差不多的样子。其实我们可以使用一个Spring自动扫描bean的功能,我们上面导入的spring-context-xxx.jar就带有这个功能,在applicationContext.xml里面加入:

        <context:annotation-config />
        <!-- 让spring自动扫描指定包下面注解@Controller,@Service,@Resposity,@Comopnent -->
        <context:component-scan base-package="com.struts2test" />

    即可,这样我们只需在类上标识@Respository,项目就会扫描到将其识别为bean,与我们显式手写一样。要调用这个bean的地方我们使用@Resource标识这个变量即可,而且这样的方式可以不写setter和getter,方便,代码也简洁。具体的用法大家可以网上搜一下,很多其他的功能我还没用过,就不多讲了。

    第三步,使用hibernate。

    如果大家接触过Microsoft MVC,就应该知道和Linq其实是差不多的一个东西,毕竟微软很多都是仿照别人的东西,只是封装的好,用起来方便而已。使用hibernate官方有一个很好的文档,有中文版的,我也是参考文档来写hibernate配置的,建议大家看文档:http://docs.jboss.org/hibernate/core/3.5/reference/zh-CN/html_single/

    使用hibernate之前,我们还需要使用数据库连接jar包,随各位想用什么数据库便下载什么jar包。我使用的是mysql,在网上下载了一个mysql-connetor-java-5.1.12.jar。

    然后也把hibernate的jar包导入:

    hibernate3.jar         commons-collections-xxx.jar          cglib-xxx.jar               jta-xxx.jar

    antlr-xxx.jar           dom4j-xxx.jar                              slf4j-api-xxx.jar          slf4j-log4j12-xxx.jar

    新建com.struts2test.vo包放数据库对应类和映射文件,新建一个Users类作为登陆用户类即可,其中包括username和password两个属性即可,记得给他们setter和getter。

    OK之后,还要建立这个类的数据库映射,我们必须告诉数据库那个类对应哪个表,哪个属性对应哪个字段。同样在com.struts2test.vo包下新建一个Users.hbm.xml,内容如下:

    复制代码
    <?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 package="com.struts2test.vo">
    
        <class name="Users" table="Users">
            <id name="username" column="username" type="string">
                <generator class="native" />
            </id>
            <property name="password" column="password" type="string" />
        </class>
    
    </hibernate-mapping>
    复制代码

    以上显示username是<id>,说明username是主键。我们数据库建立表的时候也必须给Users表username字段设置为主键。貌似没有主键是不行的 - - 当然给每张表建立主键是一个好习惯,即使不会使用到也应该建立。

    最后我们在src目录下新建一个hibernate数据库连接配置文件hibernate.cfg.xml,内容如下:

    复制代码
    <?xml version='1.0' encoding='utf-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
            "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    
    
    <hibernate-configuration>
    
        <session-factory>
    
            <!-- Database connection settings -->
            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="connection.url">jdbc:mysql://localhost:3306/MySQL</property>
            <property name="connection.username">数据库用户名</property>
            <property name="connection.password">数据库密码</property>
    
            <!-- JDBC connection pool (use the built-in) -->
            <!-- <property name="connection.pool_size">1</property> -->
    
            <!-- SQL dialect SQL方言,选择你的数据库方言 -->
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    
            <!-- Enable Hibernate's automatic session context management -->
            <property name="current_session_context_class">thread</property>
    
            <!-- Disable the second-level cache -->
            <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
    
            <!-- Echo all executed SQL to stdout -->
            <property name="show_sql">true</property>
    
            <!-- Drop and re-create the database schema on startup -->
            <!-- <property name="hbm2ddl.auto">update</property> -->
    
            <mapping resource="com/struts2test/vo/Users.hbm.xml" />
    
        </session-factory>
    
    </hibernate-configuration>
    复制代码

    这里很多property参数,大家可以看文档介绍或网上搜,具体就不说了。最主要的是<mapping resource>这行,hibernate的映射文件应该都写在这里,也就是使用的表都要在这里mapping一下。

    这样便完成了数据库映射。

    但是针对我们的登录,仍然需要将数据库映射数据Select出来,看页面传值与数据库映射数据是否对应。于是新建一个com.struts2test.dao包,包下新建一个UserDao类。内容如下:

    复制代码
    package com.struts2test.dao;
    
    import org.hibernate.Query;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    import com.struts2test.vo.Users;
    
    public class UserDao {
    
        public boolean Login(Users login){
            Configuration cfg = new Configuration();
            SessionFactory factory = cfg.configure().buildSessionFactory();
            Session session = factory.openSession();
            Query q = session.createQuery("from Users where 1 = 1 and username = '" + login.getUsername() + "' and password = '" + login.getPassword() + "'");
            User user = (User)q.uniqueResult();
            if(user != null)
                return true;
            return false;
        }
    }
    复制代码

    hibernate查询的方式大致如上面所示:Configuration -> SessionFactory -> Session -> Query。算是一个固定的方式。参考hibernate文档就可以了。

    上面类似SQL的查询语句中from Users这个Users不是指数据库的表了,而是Users类,以前犯过错误我定义类名时定义成User,而数据库里是Users,映射也对了,但是怎么也查询不出来,主要就是由于这个原因,hibernate完成映射后查询就面对对象了。

    我们使用这样的方式,所以我们要修改LoginAction判断方式,LoginAction方法需要调用UserDao的Login方法来判断即可。这个UserDao可以new出来,也可以Spring注入进去,因为刚学习了Spring,我就试着用Spring来注入。成功!

     

    附带一下整个项目的目录树:

     

    如上面所说的,我们导了很多包,其实我也不知道导的包是否必要,都是网上建议的。其实有个比较笨的导包方法,我们首先在空项目中导入最核心的包,如struts-core-2.3.15.1.jar,spring-core.jar,hibernate3.jar,直接编译后将会提示错误,我们看错误就可以推测仍缺哪个包。我搭建的时候看了很多网上的说法,必须要哪个哪个包,其实都不一定。比如很多都说要log4j提供读写日志功能这个包,我搭建项目没有使用到日志功能,没有加入这个包编译也是通过的。


    #1楼   2014-01-23 11:09  张萌2013   
    里面有很多 错误的地方,只能是借鉴。
    错误一:登陆jsp页面,“<form method="post" action="login">”需要改成
    <form method="post" action="login.action">

    展开全文
  • ssh入门视频之ssh2

    2009-06-23 10:23:36
    荐大家按以下顺序学习: 张孝祥java基础-> 张孝祥java高级-> 张孝祥javascript视频教程-> 俄罗斯方块视频教程-> 贪吃蛇游戏项目实战-> 张孝祥javaweb视频教程-> 张孝祥java邮件开发视频-> 传智播客Struts视频教程-> ...
  • 学习SSH必备资源,希望受益的兄弟姐妹们顶一下。
  • 一 remote ssh 官方ssh:https://code.visualstudio.com/docs/remote/ssh 官方ssh 语言能力:https://code.visualstudio.com/docs/languages/overview 官方 ssh python解释器:...
  • 本项目设计一个具有代表性的网上购书系统,目的是交换学生或读者怎样实现SSH框架整合,本项目适合于学生做毕业设计,入门中的经典之作!导入即可运行,本项目数据库采用Sql Server 2005,具体数据库已经备份到项目中...
  • 那么,下面正式开始进入正题,搭建一个 SSH完整的项目;首先,我们需要在WEB-ROOT下创建一个login.jsp(登录)页面; 在body之中填写如下代码: <!-- Struts返回页面对象需要加前缀 user.name
  • 该代码使用了ssh(strut+hibernate+spring),实现了课程的增删改查,内含登录操作界面和增删改查界面等,是学习ssh入门源代码,可完整运行,需修改数据源和建立相关数据库表。
  • I_8_ssh入门必备.rar

    2009-10-25 20:47:25
    I_8_ssh入门必备.rar I_8_ssh入门必备.rar
  • SSH2时写的入门例子

    2019-03-01 16:35:14
    Spring+hibernate+DWR整合 博文链接:https://fuliang.iteye.com/blog/172345
  • 手把手教你strut1.2+Spring+hibernate的整合,对于初学者非常有用
  • ssh入门视频之ssh1

    2009-06-23 10:21:59
    荐大家按以下顺序学习: 张孝祥java基础-> 张孝祥java高级-> 张孝祥javascript视频教程-> 俄罗斯方块视频教程-> 贪吃蛇游戏项目实战-> 张孝祥javaweb视频教程-> 张孝祥java邮件开发视频-> 传智播客Struts视频教程-> ...
  • struts,spring,hibernate 的入门程序,里面包括创建过程的文档,工程文件的原文件(jar包不含),说明文件里已经说明如何添加了 很适合入门

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,715
精华内容 13,886
关键字:

ssh入门