jsf集成spring_JSF Spring Hibernate集成示例教程

最新推荐文章于 2024-09-13 18:30:21 发布
最新推荐文章于 2024-09-13 18:30:21 发布
阅读量244 收藏 1
点赞数
文章标签： 列表 spring java maven hibernate
原文链接：https://www.journaldev.com/7122/jsf-spring-hibernate-integration-example-tutorial
版权

jsf集成spring

Welcome to JSF Spring Hibernate Integration example tutorial. In our last tutorial, we saw how to integrate JSF and Spring frameworks together. Today we will learn how to integrate JSF Spring Hibernate frameworks. This is a favorable combination where we are using the best choice for user interface, server side dependency injection and ORM tool.

欢迎使用JSF Spring Hibernate Integration示例教程。 在上一教程中，我们了解了如何将JSF和Spring框架集成在一起。 今天，我们将学习如何集成JSF Spring Hibernate框架。 在我们为用户界面，服务器端依赖项注入和ORM工具使用最佳选择的情况下，这是一个很好的组合。

JSF SpringHibernate (JSF Spring Hibernate)

Our goal is to create a single page user interface from which we can enter some data that goes into database. We get the same response page where we also show the data from the table, so newly added data should also be there on page submit.

我们的目标是创建一个单页用户界面，从中我们可以输入一些数据进入数据库。 我们在同一响应页面上也显示了表中的数据，因此新添加的数据也应该在页面提交中。

Below image shows our final spring jsf hibernate integration project structure. Let’s start now with the project and see how each of the frameworks are glued together to achieve our goal.

下图显示了我们最终的Spring jsf Hibernate集成项目结构。 现在让我们从项目开始，看看如何将每个框架粘合在一起以实现我们的目标。

JSF Spring Hibernate项目设置 (JSF Spring Hibernate Project Setup)

Create a Dynamic Web Project in Eclipse and then convert it to Maven project, so that we have basic setup ready. Now we must add required dependencies in our pom.xml file. Below is our final pom.xml file. Notice the JSF, Spring, Spring ORM and Hibernate dependencies. We are using MySQL database for our example and Apache DBCP for creating simple database connection pool.

在Eclipse中创建一个动态Web项目，然后将其转换为Maven项目，以便我们准备好基本设置。 现在，我们必须在pom.xml文件中添加所需的依赖项。 以下是我们最终的pom.xml文件。 注意JSF，Spring，Spring ORM和Hibernate依赖项。 我们使用MySQL数据库作为示例，使用Apache DBCP创建简单的数据库连接池。 

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>JSF_Spring_Hibernate</groupId>
	<artifactId>JSF_Spring_Hibernate</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<properties>

		<!-- Generic properties -->
		<java.version>1.6</java.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<!-- Spring -->
		<spring-framework.version>4.0.3.RELEASE</spring-framework.version>
		<aspectj.version>1.7.4</aspectj.version>

		<!-- Hibernate / JPA -->
		<hibernate.version>4.3.5.Final</hibernate.version>

		<!-- JSF Version -->
		<jsf.version>2.2.10</jsf.version>

		<!-- Logging -->
		<logback.version>1.0.13</logback.version>
		<slf4j.version>1.7.5</slf4j.version>

	</properties>

	<dependencies>
		<!-- Spring and Transactions -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<!-- @Inject -->
		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>
		<!-- AspectJ -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${aspectj.version}</version>
		</dependency>
		<!-- Spring ORM support -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>

		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate.version}</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.9</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>

		<!-- JSF Dependencies -->
		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-api</artifactId>
			<version>${jsf.version}</version>
		</dependency>

		<dependency>
			<groupId>com.sun.faces</groupId>
			<artifactId>jsf-impl</artifactId>
			<version>${jsf.version}</version>
		</dependency>

		<!-- Logging with SLF4J & LogBack -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
			<scope>runtime</scope>
		</dependency>
		<!-- https://repo1.maven.org/maven -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
		</dependency>

		<dependency>
			<groupId>com.sun.el</groupId>
			<artifactId>el-ri</artifactId>
			<version>1.0</version>
		</dependency>

		<dependency>
			<groupId>javax</groupId>
			<artifactId>javaee-web-api</artifactId>
			<version>7.0</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
				</configuration>
			</plugin>
		</plugins>
		<finalName>${project.artifactId}</finalName>
	</build>
</project>

Now use below script to create the required table in database.

现在，使用以下脚本在数据库中创建所需的表。 

CREATE TABLE `Person` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `country` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

Next we need is to add Spring Listener and JSF Controller Servlet in the web.xml file as shown below.

接下来，我们需要在web.xml文件中添加Spring Listener和JSF Controller Servlet，如下所示。 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1" xmlns="https://xmlns.jcp.org/xml/ns/javaee" 
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee 
https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
    
  <listener>
	<listener-class>
		org.springframework.web.context.ContextLoaderListener
	</listener-class>
  </listener>
  <listener>
	<listener-class>
		org.springframework.web.context.request.RequestContextListener
	</listener-class>
  </listener>
    
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Development</param-value>
    </context-param>
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    
</web-app>

Next we need JSF to integrate with Spring framework, for that we need to configure SpringBeanFacesELResolver in faces-config.xml file. It will make sure that JSF view pages variables are mapped to the backend managed beans.

接下来，我们需要JSF与Spring框架集成，为此，我们需要在faces-config.xml文件中配置SpringBeanFacesELResolver 。 它将确保将JSF视图页面变量映射到后端托管Bean。

faces-config.xml

faces-config.xml 

<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="2.2"
              xmlns="https://xmlns.jcp.org/xml/ns/javaee"
              xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee 
              https://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd">

    <application>
        <el-resolver>
            org.springframework.web.jsf.el.SpringBeanFacesELResolver
        </el-resolver>
    </application>
    
</faces-config>

The last configuration we need is the spring beans configuration but we will look at that after going through the java classes.

我们需要的最后一个配置是spring bean配置，但是在遍历java类之后我们将对其进行研究。

JSF Spring Hibernate模型类 (JSF Spring Hibernate Model Classes)

We have Person.java class that is mapped with the Person table in database. Notice the use of JPA and JSF annotations.

我们有Person.java类，该类与数据库中的Person表映射。 注意使用JPA和JSF批注。 

package com.journaldev.springhibernate.model;

import javax.faces.bean.ManagedBean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
 
/**
 * Entity bean with JPA annotations
 * Hibernate provides JPA implementation
 * @author pankaj
 *
 */
@Entity
@Table(name="PERSON")
@ManagedBean(name="person")
public class Person {
	@Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
     
    private String name;
     
    private String country;
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getCountry() {
        return country;
    }
 
    public void setCountry(String country) {
        this.country = country;
    }
     
    @Override
    public String toString(){
        return "id="+id+", name="+name+", country="+country;
    }
}

Now we will move over to creating DAO classes to interact with the database tables.

现在，我们将继续创建DAO类以与数据库表进行交互。

JSF Spring Hibernate DAO类 (JSF Spring Hibernate DAO Classes)

PersonDAO.java

PersonDAO.java 

package com.journaldev.springhibernate.dao;

import java.util.List;

import com.journaldev.springhibernate.model.Person;
 
public interface PersonDAO {
 
    public void addPerson(Person p);
    public List<Person> listPersons();
}

We have two method, one to insert data into database table and another one to fetch the list of Persons to display in user interface.

我们有两种方法，一种是将数据插入数据库表，另一种是获取要在用户界面中显示的人员列表。

Below is the implementation class for above DAO.

下面是以上DAO的实现类。

PersonDAOImpl.java

PersonDAOImpl.java 

package com.journaldev.springhibernate.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import com.journaldev.springhibernate.model.Person;

@Repository
public class PersonDAOImpl implements PersonDAO{
	
	private static final Logger logger = LoggerFactory.getLogger(PersonDAOImpl.class);
	 
    private SessionFactory sessionFactory;
     
    public void setSessionFactory(SessionFactory sf){
        this.sessionFactory = sf;
    }
 
    @Override
    public void addPerson(Person p) {
        Session session = this.sessionFactory.getCurrentSession();
        session.persist(p);
        logger.info("Person saved successfully, Person Details="+p);
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public List<Person> listPersons() {
        Session session = this.sessionFactory.getCurrentSession();
        List<Person> personsList = session.createQuery("from Person").list();
        for(Person p : personsList){
            logger.info("Person List::"+p);
        }
        return personsList;
    }
 
}

Now we will create service classes and then do the wiring.

现在，我们将创建服务类，然后进行接线。

JSF Spring Hibernate服务类 (JSF Spring Hibernate Service Classes)

PersonService.java

PersonService.java 

package com.journaldev.springhibernate.service;

import java.util.List;

import com.journaldev.springhibernate.model.Person;
 
public interface PersonService {
 
    public void addPerson(Person p);
    public List<Person> listPersons();
     
}

PersonServiceImpl.java

PersonServiceImpl.java 

package com.journaldev.springhibernate.service;

import java.util.List;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.journaldev.springhibernate.dao.PersonDAO;
import com.journaldev.springhibernate.model.Person;

@Service
@ManagedBean(name="personService")
@SessionScoped
public class PersonServiceImpl implements PersonService {

	private PersonDAO personDAO;
	 
    public void setPersonDAO(PersonDAO personDAO) {
        this.personDAO = personDAO;
    }
 
    @Override
    @Transactional
    public void addPerson(Person p) {
        this.personDAO.addPerson(p);
    }
 
    @Override
    @Transactional
    public List<Person> listPersons() {
        return this.personDAO.listPersons();
    }
 
}

Notice the use of @ManagedBean JSF annotation and @Transactional annotation for transaction management.

注意，@ @ManagedBean JSF批注和@Transactional批注用于事务管理。

Recommended Read: Spring Hibernate Integration and Spring Transaction Management

推荐阅读 ： Spring Hibernate集成和Spring事务管理

Spring Beans配置文件 (Spring Beans Configuration File)

Our Spring Hibernate based backend services are ready, now we can wire them in the spring beans configuration file as shown below.

我们基于Spring Hibernate的后端服务已经准备就绪，现在我们可以将它们连接到spring bean配置文件中，如下所示。

applicationContext.xml

applicationContext.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context" xmlns:tx="https://www.springframework.org/schema/tx"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
        https://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing 
		infrastructure -->

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving 
		up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />


	<beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<beans:property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<beans:property name="url"
			value="jdbc:mysql://localhost:3306/TestDB" />
		<beans:property name="username" value="pankaj" />
		<beans:property name="password" value="pankaj123" />
	</beans:bean>

	<!-- Hibernate 4 SessionFactory Bean definition -->
	<beans:bean id="hibernate4AnnotatedSessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<beans:property name="dataSource" ref="dataSource" />
		<beans:property name="annotatedClasses">
			<beans:list>
				<beans:value>com.journaldev.springhibernate.model.Person</beans:value>
			</beans:list>
		</beans:property>
		<beans:property name="hibernateProperties">
			<beans:props>
				<beans:prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect
				</beans:prop>
				<beans:prop key="hibernate.show_sql">true</beans:prop>
			</beans:props>
		</beans:property>
	</beans:bean>

	<beans:bean id="personDAO"
		class="com.journaldev.springhibernate.dao.PersonDAOImpl">
		<beans:property name="sessionFactory"
			ref="hibernate4AnnotatedSessionFactory" />
	</beans:bean>
	<beans:bean id="personService"
		class="com.journaldev.springhibernate.service.PersonServiceImpl">
		<beans:property name="personDAO" ref="personDAO"></beans:property>
	</beans:bean>
	
	<context:component-scan base-package="com.journaldev" />

	<tx:annotation-driven transaction-manager="transactionManager" />

	<beans:bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<beans:property name="sessionFactory"
			ref="hibernate4AnnotatedSessionFactory" />
	</beans:bean>

</beans:beans>

Notice the dataSource configuration, you will have to adjust them according to your setup.

注意dataSource配置，您将必须根据设置进行调整。

JSF查看页面 (JSF View Page)

The last part is to write JSF view page and use the managed beans as configured above.

最后一部分是编写JSF视图页面并使用上面配置的托管Bean。

person.xhtml

person.xhtml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="https://www.w3.org/1999/xhtml"
	xmlns:h="https://java.sun.com/jsf/html"
	xmlns:ui="https://java.sun.com/jsf/facelets"
	xmlns:c="https://java.sun.com/jsp/jstl/core">
<h:head>
	<title>JSF Spring Hibernate Integration</title>
	<style type="text/css">
.tg {
	border-collapse: collapse;
	border-spacing: 0;
	border-color: #ccc;
}

.tg td {
	font-family: Arial, sans-serif;
	font-size: 14px;
	padding: 10px 5px;
	border-style: solid;
	border-width: 1px;
	overflow: hidden;
	word-break: normal;
	border-color: #ccc;
	color: #333;
	background-color: #fff;
}

.tg th {
	font-family: Arial, sans-serif;
	font-size: 14px;
	font-weight: normal;
	padding: 10px 5px;
	border-style: solid;
	border-width: 1px;
	overflow: hidden;
	word-break: normal;
	border-color: #ccc;
	color: #333;
	background-color: #f0f0f0;
}

.tg .tg-4eph {
	background-color: #f9f9f9
}
</style>
</h:head>
<h:body>
	<h1>Add a Person</h1>
	<h:form>
		<table>
			<tr>
				<td><label>Name</label></td>
				<td><h:inputText id="name" value="#{person.name}"></h:inputText>
				</td>
			</tr>
			<tr>
				<td><label>Country</label></td>
				<td><h:inputText id="country" value="#{person.country}"></h:inputText>
				</td>
			</tr>
			<tr>
				<td colspan="2"><h:commandButton
						action="#{personService.addPerson(person)}" value="Add Person"></h:commandButton>
				</td>
			</tr>

		</table>

	</h:form>

	<br>
	<h3>Persons List</h3>
	

	<c:if test="${!empty personService.listPersons()}">
		<table class="tg">
			<tr>
				<th width="80">Person ID</th>
				<th width="120">Person Name</th>
				<th width="120">Person Country</th>
			</tr>
			<ui:repeat value="${personService.listPersons()}" var="person">
				<tr>
					<td>${person.id}</td>
					<td>${person.name}</td>
					<td>${person.country}</td>
				</tr>
			</ui:repeat>
		</table>
	</c:if>

</h:body>
</html>

That’s it, now just deploy the application in your favorite servlet container and run it, you should get below page.

就是这样，现在只需将应用程序部署到您喜欢的servlet容器中并运行它，您将获得以下页面。

I already have some entries in the Person table and that is shown in the list above, for the first time you won’t see the list.

我已经在Person表中有一些条目，并且这些条目显示在上面的列表中，这是您第一次看不到该列表。

As always, you can download the project from below link and play around with it to learn more.

与往常一样，您可以从下面的链接下载该项目并进行试用以了解更多信息。

翻译自: https://www.journaldev.com/7122/jsf-spring-hibernate-integration-example-tutorial

jsf集成spring

cunchi4221
关注
JSF+Spring+Hibernate(框架整合)详细过程
12-23
JSF+Spring+Hibernate(框架整合)详细过程,有代码和视图
jsf+hibernate+spring集成案例
09-13
sf + spring + hibernate 开发示例 以下是用例图，用户可以进行以下操作：登录、浏览、注册、修改、删除、退出
JSF+Spring+JPA(Hibernate实现)的环境搭建
suhuanzheng7784877的专栏
06-23 1175
<br />写之前的感受<br />刘岩<br />       先说好的，文章后再说缺点。<br />JSF+Spring+JPA以我个人看来，应该说是Struts2+Spring+Hibernate的替代解决方案。<br />引入JPA去取代或者说包装或者说是升级Hibernate是为了符合JAVA EE的规范，达到ORM统一的结果。下次项目用EJB也好、用TOPLINK也好、用ibatis也罢，我们的开发人员代价会很小。在目前很多项目来说，引入此规范，能更好的代码复用，持久层和控制层相当于进一步的解耦
整合 JSF+Spring+Hibernate的小例子
草草晴空
09-05 275
(1)UserInfo.java packagecom.zhaoqingjie.service.hibernate;importjava.io.Serializable;importorg.apache.commons.lang.builder.ToStringBuilder;publicclassUserInfoimplementsSerializable...{privateStrin...
JSF+Spring+Hibernate整合图文教程详解
11-01
JSF+Spring+Hibernate整合图文教程,超级详细。每一步都有截图还有解释。
qt.rar_jsf example_jsf spring hibernate_jsf下拉菜单_spring jsf hiber
09-22
整体来看，这个项目是一个实用的教程，旨在展示如何在同一个Web应用中有效地整合JSF、Spring和Hibernate，同时也教授如何在JSF中创建交互式的下拉菜单，这对于提升开发者在企业级Java Web开发中的技能是非常有价值的...
JSFLoginDemo.zip_JSF_JSFLoginDe_JSFLoginDemo.zip _jsf hibernate
09-24
这个登录示例项目可以帮助开发者理解如何在实际应用中整合JSF、Hibernate和Spring，实现用户认证功能。通过学习和实践这样的项目，可以提升对这些框架的掌握程度，并了解如何在实际开发中解决类似问题。
sample-jsf-spring-hibernate.rar_jsf spring
09-22
在"sample-jsf-spring-hibernate.rar"这个项目中，开发者已经将JSF、Spring和Hibernate这三大框架整合在一起，形成一个完整的应用示例。这种整合通常是为了实现以下目标： 1. **业务逻辑处理**：Spring作为中央容器...
jsf-spring-hibernate整合
02-17
此外，为了调试和测试，开发者通常会创建一些示例页面和测试用例，验证JSF、Spring和Hibernate的整合是否正确。例如，创建一个简单的CRUD（创建、读取、更新、删除）应用程序，展示如何通过JSF界面操作由Spring管理...
pam.rar_spring jsf
09-23
**JSF、Hibernate和Spring三者集成**：在这样的集成框架中，JSF处理视图层，负责展示用户界面；Hibernate在持久层工作，处理数据库交互；Spring作为中间层，管理业务逻辑、依赖注入以及事务。这种组合充分利用了各...
jsf+spring+hibernate的架构和例题
12-22
jsf+spring+hibernate的架构.主要是用maven一起使用。可以通过实体添加数据库。
Spring JSF集成教程
YunWisdom
03-13 450
Spring JSF集成教程 欢迎来到Spring JSF集成教程。JSF是一个基于组件的框架，非常注重用户界面。而Spring框架核心原则是依赖注入。因此，将JSF与Spring框架集成是有意义的，其中JSF将用于用户界面，而Spring框架将用于后端服务器端业务逻辑。 Spring JSF Springs可以与JSF集成DelegatingVariableResolver。现...
java web 整合spring_《Spring 5 官方文档》21. 与其他Web框架集成
weixin_35718242的博客
02-16 123
原文链接 译者：dan QQ：90358517721. 与其他Web框架集成21.1简介Spring Web FlowSpring Web Flow (SWF) 旨在成为管理Web应用程序页面流的最佳解决方案。SWF与Servlet和Portlet环境中的Spring MVC和JSF等现有框架集成。 如果您有一个业务流程(或流程)将受益于会话模型而不是纯粹的请求模型，则SWF可能是解决方案。S...
Jsf与Spring的整合原理
lalaandbei的专栏
11-03 927
Jsf做为Web框架,Spring做为业务层框架，两者可以结合起来用。只要在faces-config.xml中做一个很简单的配置：       org.springframework.web.jsf.el.SpringBeanFacesELResolver     ...   理解这个配置，就需要接触到Java平台中一个常用的概念：Resolver。它
jsf和spring的注解冲突
qq_29339735的博客
12-15 871
Jsf的managedbean注解 1.jsf的managedbean，由jsf框架创建并进行管理的，用于jsf页面中访问数据 2.定义managedbean （1）faces-config.xml中配置 （2）使用@ManagedBean(name = "...", eager = true)，默认eager=false即延迟实例化 （3）作用范围： @RequestScoped，默
第三章 SpringBoot项目构建 - 整合Spring Security入门
想做一个小孩的杨先生的博客
09-11 588
Spring Security 是一个强大的框架，用于保护基于 Spring 的应用程序。它提供了全面的认证和授权功能，使得安全机制与应用逻辑相分离。以下是 Spring Security 的基本使用指南，包括如何集成 Spring Security、定义用户角色和权限、以及自定义安全配置。在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
Spring Framework 学习总结博客
最新发布
2302_80084329的博客
09-13 1026
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
实战教程：JSF、Spring与Hibernate集成构建电商应用
2. 框架集成：详细解释如何将JSF与Spring Framework集成，利用Spring的依赖注入和事务管理来增强应用的灵活性和可维护性。 3. 业务逻辑定位：讨论是否应在JSF的backing beans中存放业务逻辑，以及如何保持良好的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值