首页手记 Java主流框架实战入门教程

Java主流框架实战入门教程

标签：

Java SpringBoot Spring

概述

本文详细介绍了Java主流框架实战，涵盖Spring、MyBatis、Hibernate、Servlet与JSP等框架的核心概念和使用方法。通过实际案例演示，帮助开发者提高开发效率和代码质量。文章不仅讲解了各个框架的基本用法，还提供了丰富的实战项目示例，使读者能够更好地理解和应用这些框架。

引入Java主流框架

为什么学习主流框架

在Java开发中，主流框架的掌握能够显著提高开发效率和代码质量。主流框架通过提供一系列便捷的功能和工具，使得开发者能够专注于业务逻辑的实现，而不必过多关注底层的技术细节。

学习主流框架对于以下几个方面尤其重要：

提高开发效率：主流框架提供了丰富的API和工具，使得开发过程更加高效。
提升代码质量：框架提供了最佳实践，使得代码更加规范、易于维护。
简化应用开发：框架封装了底层实现细节，使得开发者可以更简单地完成复杂的任务。
促进团队协作：统一的技术栈使得团队成员之间更容易协作和沟通。
扩展性强：主流框架通常提供了良好的扩展机制，可以根据项目需求进行灵活配置。

Java主流框架简介

Java生态中有许多主流框架，每个框架都有其独特的功能和应用场景。以下是几个常用的Java主流框架简介：

Spring框架：Spring是一个轻量级的Java框架，广泛用于企业级开发。它提供了IoC容器、依赖注入、AOP等功能。
MyBatis框架：MyBatis是一个持久层框架，用于简化数据库操作，支持多种数据库。
Hibernate框架：Hibernate是另一个流行的持久层框架，它提供了ORM（对象关系映射）功能，简化了Java对象与数据库表之间的映射。
Servlet与JSP：Servlet是Java中用于编写服务器端工作的组件，JSP则是Java的动态网页技术，常用于构建Web应用。

Spring框架入门

Spring框架基本概念

Spring框架是一个基于Java平台的轻量级框架，旨在简化企业级应用开发。Spring框架的核心思想是依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IoC）。

依赖注入（DI）

依赖注入是一种设计模式，通过将依赖关系从代码中解耦，使组件之间的依赖关系更加松散。Spring容器负责管理这些依赖关系，并将它们注入到需要的地方。

控制反转（IoC）

控制反转是一种设计模式，它将对象的创建和管理从程序代码中移出，交由外部容器（如Spring容器）负责。这样可以提高代码的可测试性和灵活性。

Spring环境搭建与配置

搭建开发环境

安装Java：确保你的计算机上安装了JDK。
安装Maven：Maven是一个强大的构建工具，可以用来管理和构建项目。
创建项目：使用IDE（如IntelliJ IDEA或Eclipse）创建一个新的Java项目，并配置Maven。
引入Spring依赖：在项目的pom.xml文件中引入Spring核心依赖。

示例代码（pom.xml）：

<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>spring-demo</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <!-- 引入Spring核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- 其他Spring依赖 -->
        <!-- 更多依赖 -->
    </dependencies>
</project>

配置Spring容器

Spring容器负责管理对象的创建和依赖注入。常见的配置方式有XML配置和Java配置。

XML配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="exampleBean" class="com.example.ExampleBean">
        <property name="property1" value="value1"/>
        <property name="property2" ref="anotherBean"/>
    </bean>
    <bean id="anotherBean" class="com.example.AnotherBean"/>
</beans>

Java配置：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public ExampleBean exampleBean() {
        ExampleBean bean = new ExampleBean();
        bean.setProperty1("value1");
        bean.setProperty2(anotherBean());
        return bean;
    }

    @Bean
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
}

示例项目代码

ExampleBean.java：

public class ExampleBean {
    private String property1;
    private AnotherBean property2;

    // Getter and Setter methods
    public String getProperty1() {
        return property1;
    }

    public void setProperty1(String property1) {
        this.property1 = property1;
    }

    public AnotherBean getProperty2() {
        return property2;
    }

    public void setProperty2(AnotherBean property2) {
        this.property2 = property2;
    }
}

AnotherBean.java：

public class AnotherBean {
    // 默认实现
}

Spring核心功能实战

依赖注入

依赖注入可以手动完成，也可以通过Spring容器自动完成。

手动依赖注入：

public class ExampleBean {
    private String property1;
    private AnotherBean property2;

    public void setProperty1(String property1) {
        this.property1 = property1;
    }

    public void setProperty2(AnotherBean property2) {
        this.property2 = property2;
    }
}

自动依赖注入：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ExampleBean {
    private String property1;
    private AnotherBean property2;

    @Autowired
    public ExampleBean(AnotherBean anotherBean) {
        this.property2 = anotherBean;
    }
}

AOP（面向切面编程）

AOP允许你定义横切关注点（如日志、事务管理）作为切面，并将它们应用到业务逻辑代码上。

配置AOP：

import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 配置切面
}

定义切面：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Logging before the method call");
    }
}

MyBatis框架实战

MyBatis基本概念

MyBatis是一个优秀的持久层框架，它可以极大简化数据库操作。MyBatis通过XML文件或注解来配置SQL语句，并将查询结果封装成Java对象。

核心组件

SqlSessionFactory：创建SqlSession的工厂。
SqlSession：执行SQL语句的会话对象。
Mapper接口：定义了数据库的操作方法。

MyBatis环境搭建与配置

搭建开发环境

安装Java：确保你的计算机上安装了JDK。
安装Maven：使用Maven作为构建工具。
创建项目：使用IDE（如IntelliJ IDEA或Eclipse）创建一个新的Java项目，并配置Maven。
引入MyBatis依赖：在项目的pom.xml文件中引入MyBatis相关依赖。

示例代码（pom.xml）：

<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>mybatis-demo</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <!-- 引入MyBatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!-- 引入数据库驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <!-- 其他依赖 -->
        <!-- 更多依赖 -->
    </dependencies>
</project>

配置MyBatis

XML配置文件（mybatis-config.xml）：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="User" type="com.example.User"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>
``

#### 示例项目代码

**User.java**：
```java
public class User {
    private int id;
    private String name;
    private String email;

    // Getter and Setter methods
    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

UserMapper.java：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id=#{id}")
    User selectUserById(int id);
}

MyBatis常用操作实战

动态SQL

动态SQL允许你根据运行时的条件生成不同的SQL语句。

XML配置（UserMapper.xml）：

<mapper namespace="com.example.UserMapper">
    <select id="selectUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <select id="selectUserByName" resultType="com.example.User">
        SELECT * FROM users WHERE name = #{name}
    </select>
</mapper>

Java代码：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.SqlSession;
import com.example.User;
import com.example.UserMapper;

public class Main {
    public static void main(String[] args) {
        try {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
            SqlSession session = factory.openSession();
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.selectUserById(1);
            System.out.println(user);
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注解配置

MyBatis支持使用注解来配置SQL语句。

Mapper接口：

import org.apache.ibatis.annotations.Select;
import com.example.User;

public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectUserById(int id);
}

Java代码：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.SqlSession;
import com.example.User;
import com.example.UserMapper;

public class Main {
    public static void main(String[] args) {
        try {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
            SqlSession session = factory.openSession();
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.selectUserById(1);
            System.out.println(user);
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Hibernate框架入门

Hibernate基本概念

Hibernate是一个持久层框架，它通过ORM（对象关系映射）技术将Java对象映射到数据库表。Hibernate的核心功能是将对象的操作转换为SQL语句，以实现数据持久化。

核心组件

Session：代表与数据库的会话，用于执行数据库操作。
Transaction：事务管理。
Query：执行SQL查询。
Criteria：执行基于对象的查询。

Hibernate环境搭建与配置

搭建开发环境

安装Java：确保你的计算机上安装了JDK。
安装Maven：使用Maven作为构建工具。
创建项目：使用IDE（如IntelliJ IDEA或Eclipse）创建一个新的Java项目，并配置Maven。
引入Hibernate依赖：在项目的pom.xml文件中引入Hibernate相关依赖。

示例代码（pom.xml）：

<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>hibernate-demo</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <!-- 引入Hibernate依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.28.Final</version>
        </dependency>
        <!-- 引入数据库驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <!-- 其他依赖 -->
        <!-- 更多依赖 -->
    </dependencies>
</project>

配置Hibernate

Hibernate配置文件（hibernate.cfg.xml）：

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

示例项目代码

User.java：

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User {
    @Id
    private int id;
    private String name;
    private String email;

    // Getter and Setter methods
    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 getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Hibernate常用操作实战

定义实体

定义一个Java类作为实体类，并使用注解或XML文件映射到数据库表。

实体类（User.java）：

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User {
    @Id
    private int id;
    private String name;
    private String email;

    // Getter and Setter methods
    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 getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

基本CRUD操作

增删改查操作：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.example.User;

public class Main {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure().buildSessionFactory();
        Session session = factory.openSession();

        try {
            session.beginTransaction();

            // Create
            User user = new User();
            user.setName("John Doe");
            user.setEmail("john.doe@example.com");
            session.save(user);
            session.getTransaction().commit();

            // Read
            User user2 = session.get(User.class, 1);
            System.out.println(user2.getName());

            // Update
            user2.setEmail("john.doe2@example.com");
            session.update(user2);
            session.getTransaction().commit();

            // Delete
            session.delete(user2);
            session.getTransaction().commit();
        } finally {
            session.close();
            factory.close();
        }
    }
}

事务管理

事务管理：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.example.User;

public class Main {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure().buildSessionFactory();
        Session session = factory.openSession();

        try {
            session.beginTransaction();
            User user = new User();
            user.setName("Jane Doe");
            user.setEmail("jane.doe@example.com");
            session.save(user);
            session.getTransaction().commit();
        } catch (Exception e) {
            session.getTransaction().rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

Servlet与JSP基础

Servlet与JSP介绍

Servlet是Java中用于编写服务器端组件的技术，通常用于处理HTTP请求和响应。JSP（JavaServer Pages）则是Java的动态网页技术，允许将Java代码与HTML、XML等静态内容结合起来。

Servlet

Servlet是运行在服务器上的Java类，可以处理HTTP请求并生成响应。Servlet容器负责管理Servlet的生命周期。

创建Servlet：

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/exampleServlet")
public class ExampleServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

JSP

JSP允许在HTML中嵌入Java代码，生成动态的网页内容。JSP页面经过编译后，会转换成Servlet类。

创建JSP页面（example.jsp）：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Example JSP Page</title>
</head>
<body>
    <h1>Hello, World!</h1>
    <%
        String message = "This is a JSP page!";
        out.println(message);
    %>
</body>
</html>

Servlet与JSP环境搭建

搭建开发环境

安装Java：确保你的计算机上安装了JDK。
安装Maven：使用Maven作为构建工具。
创建项目：使用IDE（如IntelliJ IDEA或Eclipse）创建一个新的Java项目，并配置Maven。
引入Servlet/JSP依赖：在项目的pom.xml文件中引入Servlet/JSP相关依赖。

示例代码（pom.xml）：

<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>servlet-jsp-demo</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <!-- 引入Servlet/JSP依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

配置Web应用

web.xml：

<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_3_1.xsd"
         version="3.1">
    <servlet>
        <servlet-name>ExampleServlet</servlet-name>
        <servlet-class>com.example.ExampleServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ExampleServlet</servlet-name>
        <url-pattern>/exampleServlet</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

示例项目代码

Servlet代码（ExampleServlet.java）：

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/exampleServlet")
public class ExampleServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

JSP代码（index.jsp）：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Example JSP Page</title>
</head>
<body>
    <h1>Hello, World!</h1>
    <%
        String message = "This is a JSP page!";
        out.println(message);
    %>
</body>
</html>

实战项目演示

整合Spring与MyBatis项目案例

项目结构

src
└── main
    ├── java
    │   └── com
    │       └── example
    │           ├── dao
    │           │   └── UserMapper.java
    │           ├── domain
    │           │   └── User.java
    │           ├── service
    │           │   └── UserService.java
    │           └── App.java
    └── resources
        └── mybatis-config.xml

用户实体类

User.java：

public class User {
    private int id;
    private String name;
    private String email;

    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

用户Mapper接口

UserMapper.java：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id=#{id}")
    User selectUserById(int id);
}

用户服务类

UserService.java：

import com.example.dao.UserMapper;
import com.example.domain.User;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSession;

public class UserService {
    private UserMapper userMapper;

    public UserService(SqlSessionFactory sqlSessionFactory) {
        SqlSession session = sqlSessionFactory.openSession();
        this.userMapper = session.getMapper(UserMapper.class);
    }

    public User getUserById(int id) {
        return userMapper.selectUserById(id);
    }
}

主程序

App.java：

import com.example.domain.User;
import com.example.service.UserService;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class App {
    public static void main(String[] args) throws Exception {
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
        UserService userService = new UserService(factory);
        User user = userService.getUserById(1);
        System.out.println(user);
    }
}

整合Spring与Hibernate项目案例

项目结构

src
└── main
    ├── java
    │   └── com
    │       └── example
    │           ├── entity
    │           │   └── User.java
    │           ├── service
    │           │   └── UserService.java
    │           └── App.java
    └── resources
        └── hibernate.cfg.xml

用户实体类

User.java：

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User {
    @Id
    private int id;
    private String name;
    private String email;

    // Getter and Setter methods
    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 getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

用户服务类

UserService.java：

import com.example.entity.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class UserService {
    private SessionFactory sessionFactory;

    public UserService() {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    public User getUserById(int id) {
        Session session = sessionFactory.openSession();
        User user = session.get(User.class, id);
        session.close();
        return user;
    }
}

主程序

App.java：

import com.example.entity.User;
import com.example.service.UserService;

public class App {
    public static void main(String[] args) {
        UserService userService = new UserService();
        User user = userService.getUserById(1);
        System.out.println(user);
    }
}

总结

通过以上教程，你已经掌握了Spring、MyBatis、Hibernate、Servlet与JSP的基本概念和使用方法。通过实践示例，你可以更好地理解这些框架的实际应用。这些框架是Java开发中的重要工具，可以帮助你提高开发效率和代码质量。继续深入学习和实践，你将能够更熟练地使用这些框架来构建复杂的应用程序。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

拉莫斯之舞

手记
篇

粉丝

25

获赞与收藏

110

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19366 315

Java 并发原理入门教程

26个小节 39077 568

Java 入门教程

50个小节 342223 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java主流框架实战入门教程

为什么学习主流框架

Java主流框架简介

Spring框架基本概念

依赖注入（DI）

控制反转（IoC）

Spring环境搭建与配置

搭建开发环境

配置Spring容器

示例项目代码

Spring核心功能实战

依赖注入

AOP（面向切面编程）

MyBatis基本概念

核心组件

MyBatis环境搭建与配置

搭建开发环境

配置MyBatis

MyBatis常用操作实战

动态SQL

注解配置

Hibernate基本概念

核心组件

Hibernate环境搭建与配置

搭建开发环境

配置Hibernate

示例项目代码

Hibernate常用操作实战

定义实体

基本CRUD操作

事务管理

Servlet与JSP介绍

Servlet

JSP

Servlet与JSP环境搭建

搭建开发环境

配置Web应用

示例项目代码

整合Spring与MyBatis项目案例

项目结构

用户实体类

用户Mapper接口

用户服务类

主程序

整合Spring与Hibernate项目案例

项目结构

用户实体类

用户服务类

主程序

阅读免费教程