spring集成JSF、Hibernate

最新推荐文章于 2021-11-10 16:02:59 发布
最新推荐文章于 2021-11-10 16:02:59 发布
阅读量251 收藏
点赞数 3
文章标签： hibernate spring maven jsf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happy488127311/article/details/120539883
版权

创建一个JSF项目，推荐用Tomcat做服务器

IDEA 2020.2 部署JSF项目

导入依赖项

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jsf-hibernate-01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>4.1.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.5.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.5.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-api</artifactId>
            <version>2.1.7</version>
        </dependency>
        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-impl</artifactId>
            <version>2.1.7</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.0-alpha1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</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>8.0.1</version>
        </dependency>
    </dependencies>

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

创建 faces-config.xml，配置SpringBeanFacesELResolver在faces，进行JSF与Spring框架集成

<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="2.2" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
    http://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>

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <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>*.xhtml</url-pattern>
    </servlet-mapping>

    <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>

    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>index.xhtml</welcome-file>
    </welcome-file-list>
</web-app>

创建实体类

package org.example.pojo;


import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 * @Author: HAPPY
 * @Project_name: JSF
 * @Package_name: org.example.pojo
 * @Date: 2021/9/27 21:53
 */
@Entity(name = "student")
@ManagedBean(name = "student")
@RequestScoped
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

创建service

package org.example.service;

import org.example.pojo.Student;

import java.util.List;

/**
 * @Author: HAPPY
 * @Project_name: JSF
 * @Package_name: org.example.service
 * @Date: 2021/9/28 20:28
 */
public interface StudentService {
    boolean insertStudent(Student student);

    Student selectStudentById(Integer id);

    List<Student> selectAllStudents();

    boolean deleteStudentById();
}

实现service

package org.example.service.impl;

import org.example.dao.StudentDAO;
import org.example.dao.impl.StudentDAOImpl;
import org.example.pojo.Student;
import org.example.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import java.util.List;

/**
 * @Author: HAPPY
 * @Project_name: JSF
 * @Package_name: org.example.service.impl
 * @Date: 2021/9/28 20:37
 */
@Service("studentService")
@ManagedBean(name = "studentService")
@SessionScoped
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentDAO studentDAO;

    @Override
    public boolean insertStudent(Student student) {
        System.out.println(student);
        return studentDAO.insertStudent(student);
    }

    @Override
    public Student selectStudentById(Integer id) {
        return studentDAO.selectStudentById(id);
    }

    @Override
    @Transactional
    public List<Student> selectAllStudents() {
        return studentDAO.selectAllStudents();
    }

    @Override
    public boolean deleteStudentById() {
        return studentDAO.deleteStudentById();
    }

    public StudentDAO getStudentDAO() {
        return studentDAO;
    }

    public void setStudentDAO(StudentDAO studentDAO) {
        this.studentDAO = studentDAO;
    }
}

创建dao

package org.example.dao;

import org.example.pojo.Student;

import java.util.List;

/**
 * @Author: HAPPY
 * @Project_name: JSF
 * @Package_name: org.example.dao
 * @Date: 2021/9/28 20:28
 */
public interface StudentDAO {
    boolean insertStudent(Student student);

    Student selectStudentById(Integer id);

    List<Student> selectAllStudents();

    boolean deleteStudentById();
}

实现dao

package org.example.dao.impl;

import org.example.dao.StudentDAO;
import org.example.pojo.Student;
import org.example.util.SessionFactoryUtil;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author: HAPPY
 * @Project_name: JSF
 * @Package_name: org.example.dao.impl
 * @Date: 2021/9/28 20:38
 */

@Repository
public class StudentDAOImpl implements StudentDAO {
    @Override
    public boolean insertStudent(Student student) {
        Session session = SessionFactoryUtil.getSessionFactory().openSession();
        Transaction transaction = session.beginTransaction();
        try {
            session.save(student);
            transaction.commit();
            return true;
        } catch (Exception a) {
            return false;
        }
    }

    @Override
    public Student selectStudentById(Integer id) {
        return null;
    }

    @Override
    public List<Student> selectAllStudents() {
        Session session = SessionFactoryUtil.getSessionFactory().openSession();
        Query query = session.createQuery("FROM org.example.pojo.Student");
        return query.list();
    }

    @Override
    public boolean deleteStudentById() {
        return false;
    }
}

创建工具类

package org.example.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * 获取SessionFactory 的工具类
 */
public class SessionFactoryUtil {
    static SessionFactory sessionFactory;
    static {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
}

创建spring 配置文件， applicationContext.xml

<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:mvc="http://www.springframework.org/schema/mvc" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--加载驱动文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}"/>
        <property name="username" value="${jdbc_username}"/>
        <property name="password" value="${jdbc_password}"/>
    </bean>

    <!-- service 对象， 用的component-scan 好像没有用，报空指针 -->
    <bean id="studentService" class="org.example.service.impl.StudentServiceImpl">
        <property name="studentDAO" ref="studentDAOImpl"/>
    </bean>

    <!-- hibernate用来创建sessionFactory -->
    <bean id="hibernate4AnnotatedSessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 受管bean -->
        <property name="annotatedClasses">
            <list>
                <value>org.example.pojo.Student</value>
            </list>
        </property>
        <!-- 配置属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

    <!-- 事务注解扫描 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

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

    <!-- 组件扫描器，用于创建service对象，好像没用-->
    <context:component-scan base-package="org.example"/>

    <!--注解驱动-->
    <mvc:annotation-driven/>
</beans>

配置文件 jdbc.properties

jdbc_url=jdbc:mysql://localhost:3306/esms
jdbc_username=root
jdbc_password=123456

创建页面 index.xhtml

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

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:c="http://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="#{student.name}"/></td>
         </tr>
         <tr>
            <td><label>Address</label></td>
            <td><h:inputText id="address" value="#{student.address}"/></td>
         </tr>
         <tr>
            <td colspan="2">
               <h:commandButton action="#{studentService.insertStudent(student)}" value="添加学生" />
            </td>
         </tr>
      </table>
   </h:form>
   <br/>
   <h3>Persons List</h3>

   <c:if test="${!empty studentService.selectAllStudents()}">
      <table class="tg">
         <tr>
            <th width="80">Student ID</th>
            <th width="120">Student Name</th>
            <th width="120">Student Address</th>
         </tr>
         <ui:repeat value="${studentService.selectAllStudents()}" var="stu">
            <tr>
               <td>${stu.id}</td>
               <td>${stu.name}</td>
               <td>${stu.address}</td>
            </tr>
         </ui:repeat>
      </table>
   </c:if>
</h:body>
</html>

建表

create table student
(
	id int auto_increment,
	name varchar(50) null,
	address varchar(50) null,
	constraint student_pk
	primary key (id)
);

部署运行

在这里插入图片描述

别来BUG求求了
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
spring+jsf
05-10
jsf+spring集成案例 jar自己下载
JSF与Spring完美结合
04-23
spring2.5 与 jsf RI 集成后的猜数字游戏 tomcat6下部署运行
spring 与 jsf整合
修也
04-13 856
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/we
Spring JSF集成教程
YunWisdom
03-13 438
Spring JSF集成教程 欢迎来到Spring JSF集成教程。JSF是一个基于组件的框架，非常注重用户界面。而Spring框架核心原则是依赖注入。因此，将JSF与Spring框架集成是有意义的，其中JSF将用于用户界面，而Spring框架将用于后端服务器端业务逻辑。 Spring JSF Springs可以与JSF集成DelegatingVariableResolver。现...
JSF（JavaServer Face）标签库简介(JavaEE)
code袁的博客
11-10 1396
JSF（JavaServer Face）标签库简介(JavaEE) 一、JSF的简介 1. 什么是 JSF？ JavaServer Faces (JSF) 是一种用于构建 Web 应用程序的新标准 Java 框架。它提供了一种以组 件为中心来开发 Java Web 用户界面的方法，从而简化了开发。 JSF 还通过将良好构建的模型-视图-控制器 (MVC) 设计模式集成到它的体系结构中，确保了应用程 序具有更高的可维护性。 2. 功能特点 高效的 UI 设计； 前后端分离与 MVC 模式； 页面流程导航与控制
jsf-spring-hibernate整合
02-17
本项目"jsf-spring-hibernate整合"旨在将这三大技术进行无缝集成，采用基于注解的方式来简化配置，提高开发效率。 JSF（JavaServer Faces）是Java平台上的一个标准组件模型，用于构建富互联网应用程序（RIA）。它...
jsf+hibernate+spring集成案例
06-06
在这个"jsf+hibernate+spring集成案例"中，我们将看到： 1. **配置集成**：首先，我们需要在Spring配置文件中定义数据源、SessionFactory（Hibernate的核心组件）以及JSF所需的Managed Beans。这通常涉及到XML配置...
sample-jsf-spring-hibernate.rar_jsf spring
09-22
在"sample-jsf-spring-hibernate.rar"这个项目中，开发者已经将JSF、Spring和Hibernate这三大框架整合在一起，形成一个完整的应用示例。这种整合通常是为了实现以下目标： 1. **业务逻辑处理**：Spring作为中央容器...
jsf+spring+hibernate
03-21
【JSF+Spring+Hibernate整合开发】 JSF (JavaServer Faces)、Spring 和 Hibernate 是 Java 开发中的三大核心技术，常用于构建企业级的 Web 应用程序。它们各自扮演着不同的角色，共同构建了一个强大的后端架构。 1...
JSF2.2.6+Spring + Hibernate整合可运行
05-20
在JSF和Spring的环境中，Hibernate常用于管理数据库交互，Spring可以通过其JPA（Java Persistence API）支持轻松地集成Hibernate。 在这个整合项目中，开发者可能已经配置了以下关键组件： 1. **JSF配置**：JSF的...
jnr-fuse:使用Java本机运行时（JNR）在Java中实现FUSE
05-13
保险丝 jnr-fuse是Java中使用Java本机运行时（JNR）的FUSE实现。 项目目标 该项目的主要目标是提供一种在用户空间中创建高性能文件系统的简便方法。 关于技术 （用户空间中的文件系统）是一种用于类Unix操作系统的操作系统机制，它使非特权用户无需编辑内核代码即可创建自己的文件系统。 （JNR）是用于绑定本机库和本机内存的高性能Java API。 得到它 在0.5.5之前，jnr-fuse仅在可用。 由于停产，因此中从0.5.5 。 Gradle dependencies { compile ' com.github.serceman:jnr-fuse:0.5.5 ' } 玛文 < dependencies> < dependency> < groupId>com.github.serceman</ groupId>
JSF+Spring+Hibernate(框架整合)详细过程
12-23
JSF+Spring+Hibernate(框架整合)详细过程,有代码和视图
jsf-spring:JSF 和 Spring 集成
06-27
JSF 和 Spring 集成 本实验展示了如何设置 JSF 了解 Spring 组件以使用 Spring 依赖注入。 它是用 Maven 构建的，它使这个项目与 IDE 无关。 因此，构建和运行它很简单： mvn 全新安装 mvn码头：运行 然后，在某个 Web 浏览器中打开 。
Spring与JSF2的整合配置的整理
问题，总是可以解决滴
01-12 3252
目的：在JSF2中可以使用Spring中的Bean，可以通过注解方式配置使用。环境：在JSF2.2，Spring3.2.7版本测试通过。配置过程概述： 整合过程主要包括一下三个方面的配置：web.xml配置，faces-config.xml配置，ManagedBean的配置
Spring-Jsf2.0-Mybatis整合（可运行工程）
wp562846864的专栏
11-18 3224
学习了半个月的Spring 、 JSF2.0（使用Primefaces）以及Mybatis，今天来个整理，希望对以后有所帮助！ 1） 我用的是maven项目，所以jar 包以及jar包的版本都由pom文件决定，相关内容如下： xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/mav
JSF2.0与Spring3的整合
孙健的专栏
02-16 7165
关于JSF与EJB的整合资料比较少，没找到。所以以普及度很高的spring为例。步骤是非常简单的，主要有两条思路一是让所有的beanJSF的@ManagedBean和spring的@Component各自分管，经过实验他们之间的注入依赖在同一个bean里不能混用。比如如果class是@ManagedBean如果field上@Resource就会出错。只能用@ManagedProperty(value="#{xxxServiceImpl}")这样注入。而且当在class上同时@ManagedBean@Comp
整合Spring和JSF
一个大龄码农的专栏
07-10 210
1.在web配置文件里面声明ContextLoaderListener。 声明了ContextLoaderListener之后，Spring XML配置文件才会自动加载，不设置这个，就得在应用程序里面使用 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 来获取上...
Java Web层框架比较—— 比较JSF、Spring MVC、Stripes、Struts 2、Tapestry和Wicket
热门推荐
forever8tf的专栏
03-14 1万+
<br /> <br />【译者按】这是Matt Raible在今年6月24-27号召开的JA-SIG夏季会议上所作的主题演讲，Matt从众多方面对Java Web层框架做了一个全面、深入的比较。笔者认为这是一份及时的文档，它对开发者如何判定一个Web层框架的好坏、如何选择适合自己项目的框架有极大的指导作用。本文是对Matt Raible演讲稿的整理归纳。 <br />【作者介绍】Matt Raible，开源框架AppFuse的发起者、主要开发者；《Professional JSP 2.0》、《Spring
JSF实战教程中文版.docx
最新发布
09-19
此外，教程还可能探讨如何将JSF与其他技术如EJB、Spring或Hibernate集成，以构建更大型的企业级应用。 "JSF实战教程中文版"是一个全面的指南，不仅覆盖了JSF的基本概念，还深入到实际应用开发的细节，适合初学者和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

别来BUG求求了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值