English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
前言
SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。
集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层（实体层）。
Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持。Spring一方面作为一个轻量级的IoC容器，负责查找、定位、创建和管理对象及对象之间的依赖关系，另一方面能使Struts和Hibernate更好地工作。
使用MyEclipse整合SSH三大框架，并实现一个模拟用户注册的Demo，对应版本：
Struts版本：2.1；
Spring版本：3.1；
Hibernate版本：3.3；
一、整合前准备工作
1.建立一个Web项目，如下：
注意：支持action的包名必须是“action”，且action类必须是以Action结尾，即形如XxxAction这种形式，如上图中所示
2.创建数据库以及表：
CREATE DATABASE sshdemo; CREATE table t_user( id INT PRIMARY KEY, username VARCHAR(10), password VARCHAR(20) )
3.导入数据库连接池c3p0jar包，点击可下载：
c3p0-0.9.2-pre1.jar、mysql-connector-java-5.1.13-bin.jar
二、Struts框架的配置：
1.选中项目，右键选择：MyEclipse -> Project Facets[Capabilities] -> Install Apache Struts (2.x) Facet，如下：
2.选择版本，在这里我选择的是2.1，点击"Finish"，如下：
3.完成上述步骤后，您会发现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> </struts>
4. Aggiungi un pezzo di codice di configurazione del filtro struts nel file web.xml situato nella directory WEB-INF, come segue:
5. Riferendoti alla figura seguente, modifica *.action in "/*", fino a questo puntoLa configurazione del framework struts è completata;
III. Configurazione del framework Spring:
1. Riferendoti alla configurazione di struts, seleziona il progetto, clicca con il tasto destro e seleziona: MyEclipse -> Project Facets[Capacità] -> Installa Spring Facet, seleziona la versione, in questo caso seleziona 3.1 come segue:
2. Clicca su "Fine", noterai che nella directory src è stato aggiunto unapplicationContext.xmlIl file, nella directory WEB-INF è stato aggiunto un file spring-form.tld e un file spring.tld, e nel file web.xml è stato aggiunto un pezzo di codice relativo alla configurazione di spring, la costruzione del framework spring è quasi completata (l'introduzione dello spazio dei nomi verrà trattata in seguito), come segue:
IV. Configurazione del framework Hibernate:
1. Riferendoti alla configurazione di struts, seleziona il progetto, clicca con il tasto destro e seleziona: MyEclipse -> Project Facets[Capacità] -> Installa HibernateFacet, seleziona la versione, in questo caso seleziona 3.3 come segue:
2. Clicca su "Fine", noterai che nella directory src è stato aggiunto un pacchetto predefinito (può essere eliminato) e nel file web.xml è stato aggiunto un pezzo di codice (che verrà configurato di nuovo), come segue:
3. Importazione del jar pacchetto che supporta l'annotazione "@Entity": seleziona il progetto, clicca con il tasto destro e seleziona: MyEclipse -> Project Facets[Capacità] -> Gestisci... e poi segui i passaggi nella figura seguente:
Completati questi passaggi, le tre grandi framework sono基本上搭建起来了，接下来整合它们。
V. Integrazione
1. Per evitare che applicationContext.xml sembri troppo ingombrante e per facilitare la gestione, conserviamo le configurazioni di Hibernate in un altro file.xml e poi l'importiamo in applicationContext.xml, i passaggi specifici sono i seguenti:
(1) Create a file namedhibernateContext.xmlCopy the content of applicationContext.xml to the file, and then make modifications;
(2) The content of the hibernateContext.xml file:
<?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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd" <!-- Configuration of sessionFactory --> <bean id="sessionFactory"> class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <!-- The properties of dataSource will be configured in the applicationContext.xml file, and it is referenced here first --> <property name="dataSource" ref="dataSource"></property> <!-- Set the configuration items related to hibernate --> <property name="hibernateProperties"> <!-- The props tag is used to inject the Properties type attribute --> <!-- The key must be prefixed with hibernate. --> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <!-- The purpose of show_sql is to print SQL statements --> <prop key="hibernate.show_sql">true</prop> <!-- Beautify the print format of SQL --> <prop key="hibernate.format_sql">true</prop> <!-- a) create-drop: Create the data table when executing the program, and delete the table after execution, commonly used for testing in actual development --> b) create: Re-create the data table each time the program is executed c) update: During the execution of the program, it will judge whether the table exists. If it exists, it will not create the table, otherwise it will create the data table, and it will automatically add fields to the data table according to the increase of properties in the entity class (development environment) d) validate: Durante l'esecuzione del programma, viene verificato se le proprietà delle classi entità non corrispondono ai campi delle tabelle, in caso affermativo viene generato un errore (in ambiente di produzione) --> <prop key="hibernate.hbm2ddl.auto">validate</prop> </props> </property> <!-- Configurazione delle classi entità di hibernate --> <property name="packagesToScan"> <!-- Il tag list viene utilizzato per iniettare attributi di tipo String[], i valori generalmente corrispondono ai nomi completi dei pacchetti bean, e le classi nel pacchetto bean generalmente corrispondono alle tabelle nel database--> <list> <value>com.beauxie.bean</value> </list> </property> </bean> <!-- Configurazione del modello hibernateTemplate --> <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> </beans>
(3) Elimina la configurazione di "sessionFactory" in applicationContext.xml (poiché è già configurata in hibernateContext.xml), quindi importa il contenuto di hibernateContext.xml modificato. Dopo aver importato, il contenuto di applicationContext.xml sarà come segue:
<?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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd" <bean id="dataSource"}} class="org.apache.commons.dbcp.BasicDataSource"> </bean> <!-- Importare altri file di configurazione di spring, se tutti vengono messi in un unico file, potrebbe sembrare ingombrante --> <import resource="hibernateContext.xml"/> </beans>
2. Modificare la configurazione del dataSource esistente nel file applicationContext.xml (nome del database, nome utente, password, ecc.), (Attenzione: il tag value non deve contenere spazi o righe vuote!!)，come segue:
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="jdbcUrl"> <!-- Se si utilizza direttamente l'attributo value, invece che il tag value, è necessario sostituire l'& con un'escapata (&), se si utilizza il tag value, il tag <span style="color:#FF0000;">non deve contenere spazi o righe vuote, poiché trasformerà gli spazi in " ", il che potrebbe causare che il database non si connetta, a meno che non si riscrivano i dati della sorgente --> <value><![CDATA[jdbc:mysql://localhost:3306/sshdemo?useUnicode=true&characterEncoding=UTF8&useServerPrepStmts=true&prepStmtCacheSqlLimit=256&cachePrepStmts=true&prepStmtCacheSize=256&rewriteBatchedStatements=true]]></value> </property> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="acquireIncrement" value="3"></property> <property name="initialPoolSize" value="10"></property> <property name="minPoolSize" value="2"></property> <property name="maxPoolSize" value="10"></property> </bean>
3. In applicationContext.xm, configura lo scanner di spring in modo che i nostri classi possano avere annotazioni di componenti di spring per realizzare l'auto-caricamento di bean, i passaggi specifici sono i seguenti: (1) Importa lo spazio dei nomi context, supporta i tag context, fai clic su "Namespaces" in basso e seleziona l'opzione context:
(2) Configura lo scanner di spring:
<!-- Configura lo scanner di spring, poi aggiungi annotazioni di componenti a nostri classi per realizzare l'auto-caricamento di bean -->
<context:component-scan base-package="com.beauxie.action,com.beauxie.service,com.beauxie.dao">
</context:component-scan>
Fino a questo punto è stata completata la configurazione dell'ambiente delle tre grandi framework ssh, ora è necessario implementare la registrazione utente sulla base del framework ssh
6. Esempio: Simulazione di registrazione utente semplice
1. Codice della pagina di registrazione frontend, index.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>Benvenuti alla registrazione</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 action="${pageContext.request.contextPath }/user/regist" method="POST">
<!-- Puoi anche usare user.username per caricare automaticamente l'attributo user, ma non è il punto focale qui, quindi lo ottieni manualmente sullo sfondo -->
Nome utente: <input type="text" name="username"><br> Parola:
Codice: <input type="password" name="password"><br>
<input type="submit" value="Registrati">
</form>
</body>
</html>
2. Codice della classe User:
package com.beauxie.bean;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* @author Beauxie
* In questo caso, le proprietà di User devono corrispondere ai campi della tabella t_user
* Altrimenti, è necessario specificare manualmente i campi corrispondenti per le proprietà diverse
*/
@Entity//Mappatura della tabella del database
@Table(name="t_user")//Senza questa anotazione, il nome predefinito è user
public class User {
@Id//Corrisponde alla chiave primaria della tabella t_user
private int id;//ID utente
private String username;//Nome utente
private String password;//Password
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
}
3.Codice della classe UserDao:
package com.beauxie.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;
import com.beauxie.bean.User;
/**
* @author Beauxie
* Strato Dao, eseguire operazioni sul database
*/
@Repository//Questa proprietà corrisponde al livello di persistenza (solitamente Dao), indica che viene gestito da Spring, e il nome della classe nel pacchetto corrispondente avrà anche un "S"
public class UserDao {
@Autowired//Iniezione automatica, non è necessario impostare il valore, perché è già configurato nel file di configurazione di Spring
private HibernateTemplate template;
/**
* Registrazione dell'utente, ovvero aggiungere una nuova registrazione alla tabella
* @param user
*/
public void addUser(User user){
//Aggiungi una riga di dati al database, può essere risolto con una frase
template.save(user);
}
}
4. Codice della classe UserService:
package com.beauxie.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.beauxie.bean.User;
import com.beauxie.dao.UserDao;
/**
* @author Beauxie
* Livello di Service
*/
@Service//Questa proprietà corrisponde al livello di business, di solito il livello di Service, indica che viene gestito da Spring, e il nome della classe nel pacchetto corrispondente avrà anche un "S"
public class UserService {
@Autowired//Annotazione di iniezione automatica
private UserDao userDao;
public void addUser(User user){
//Chiamata al metodo addUser del livello Dao
userDao.addUser(user);
}
}
5. Codice della classe UserAction:
package com.beauxie.action;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import com.beauxie.bean.User;
import com.beauxie.service.UserService;
/**
* @author Beauxie
*
*/
@Controller// Utilizzato per etichettare i componenti di livello di controllo
@Namespace("/user")// Prefisso URL
@Scope("prototype")// L'Action è predefinito come singleton, ma nell'effettiva sviluppo, di solito è multipli, perché generalmente un Action potrebbe corrispondere a più richieste diverse
//@ParentPackage("struts-default")// Eredita un package specifico, per default è "struts-default", quindi può essere omesso
@Results({
@Result(name="registSuccess",location="/msg.jsp")
})
public class UserAction {
@Autowired// Iniezione automatica
private UserService service ;
// Struts predefinisce l'intercettamento di `.action` e senza alcun suffisso
@Action(value="regist")// Accesso: /user/regist.action o /user/regist
public String regist(){
// Ottenere request
HttpServletRequest request = ServletActionContext.getRequest();
// Ottenere i dati di submission del modulo
String username = request.getParameter("username");
String password = request.getParameter("password");
// impacchettare il bean user
User user = new User();
user.setId(1000);
user.setUsername(username);
user.setPassword(password);
// Chiamare il metodo del livello di servizio, aggiungere una registrazione alla base dati
service.addUser(user);
// Salvare le informazioni di avviso nel dominio di request, per la visualizzazione in frontend
request.setAttribute("msg", "Congratulazioni, registrazione riuscita! <br> Nome utente: " + username);
return "registSuccess";
}
}
6. Interfaccia di messaggio: codice msg.jsp, come segue:
<%@ 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>Message Prompt</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>
${msg }
</body>
</html>
7. Aggiungi il progetto al server, avvia il servizio, apri il browser, accedi a: http://localhost/SSHDemo/user/regist
8. Inserire nome utente e password, fare clic su “Registrati”, visualizzare il risultato:
9. Output di SQL nel console (è già configurato e ottimizzato nel file hibernateContext.xml):
10. Visualizzare i risultati del database:
Fino a questo punto, il caso semplice è già finito, riguardo alla convalida dei dati di submit del modulo e ai problemi di codifica sbagliata non è stato coinvolto, dovrebbe essere aggiornato in seguito吧、、、
Settimo: sommario;
1. L'integrazione delle tre principali framework dovrebbe essere introdotta prima di integrare;
2. Assicurati di importare il jar del database;
3. La classe Action dovrebbe essere collocata nella directory 'action' e il nome della classe dovrebbe finire con 'Action', come 'XxxAction';
4. Durante la configurazione di Hibernate, è necessario importare il jar che supporta l'annotazione '@Entity';
5. Puoi definire il tipo di richiesta intercettata da struts nel file struts.xml, il tipo predefinito è .action e senza suffisso
6. Puoi definire il tipo di filtro del filtro struts nel file web.xml, il tipo predefinito è *.action, dovrebbe essere cambiato in /*;
7. Nella file applicationContext.xm è necessario configurare: sessionFactory, le classi entity di hibernate, il template hibernateTemplate, il datasourse dataSource, il scanner di spring (incluso hibernateContext.xml);
8. Assicurati di aggiungere le annotazioni corrispondenti in ogni classe e anche sugli metodi dell'Action.
Download di codice di esempio:http://xiazai.jb51.net/201610/yuanma/SSHzhuce(jb51.net).rar
Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento, e ti preghiamo di sostenere e gridare le lezioni.
Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, il copyright spetta ai rispettivi autori, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato elaborato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.