首页手记 Java主流框架学习：从入门到实践指南

Java主流框架学习：从入门到实践指南

标签：

Java SpringBoot Spring

本文深入介绍了Java主流框架学习的相关内容，涵盖了Spring、MyBatis、Hibernate和Struts等多个主流框架的入门知识和应用场景。文章详细讲解了各个框架的核心特性和配置方法，帮助开发者高效地构建复杂应用系统。通过实战案例，进一步展示了如何将Spring与MyBatis整合使用，实现具体的功能开发。

Java主流框架概览

1.1 框架简介

Java主流框架是指在Java生态系统中广泛应用的、成熟的、经过时间考验的技术框架。这些框架可以帮助开发者高效地构建复杂的应用系统，提高开发效率，减少编码错误。框架通常提供了一套预定义的工具和库，能够简化开发流程，降低复杂性，提高代码的可维护性和可扩展性。

1.2 常用框架推荐

在Java开发领域，有多个主流且广泛使用的框架，以下是一些常用的框架推荐：

Spring：Spring是一个非常成熟的Java应用开发框架，它提供了全面的功能支持，包括依赖注入（DI）、面向切面编程（AOP）、Web应用开发等。
MyBatis：MyBatis是一个优秀的持久层框架，它允许开发者使用简单的XML或注解进行数据库操作，简化了数据库操作的复杂度。
Hibernate：Hibernate是另一种流行的持久层框架，专注于对象关系映射（ORM），自动处理数据库的CRUD操作。
Struts：Struts是一个流行的MVC（Model-View-Controller）框架，用于构建Web应用，提供了一套强大的标签库和配置工具。

1.3 选择合适框架的原则

选择合适的框架是基于项目需求和团队技能的综合考虑。以下是选择合适框架时可以遵循的一些基本原则：

项目规模：小项目通常不需要复杂的框架，而较大的项目可能需要更成熟、功能更为全面的框架。例如，对于小型Web应用，可以选择简单的框架如Spring Boot；而对于企业级应用，可能需要Spring、MyBatis等更全面的框架。
技术栈：选择框架时需要考虑现有技术栈的整合能力。比如，如果已有项目使用了Hibernate，那么继续使用Hibernate可能会更简单。同样，如果项目中已经使用了Spring，可能会选择Spring Boot等与之兼容的框架。
团队经验：团队成员对某些框架的熟悉程度也是一个重要的考虑因素。如果团队成员对Spring框架非常熟悉，那么优先选择Spring框架会更高效，反之亦然。
性能需求：不同框架在性能上有着不同的表现。例如，Hibernate提供了强大的性能优化工具，但有时可能需要开发者手动优化查询。而Spring Boot则提供了快速开发的能力，但也可能在某些情况下牺牲一些性能。
开发速度：需要快速开发的项目可能适合使用Spring Boot等快速开发框架。这些框架提供了许多开箱即用的特性，减少了配置和编码的时间。

Spring框架入门

2.1 Spring简介

Spring框架是一个非常成熟且功能丰富的Java应用开发框架。它通过提供一系列的工具和库，帮助开发者构建健壮、可维护的应用系统。Spring框架的核心是依赖注入（DI）和面向切面编程（AOP）机制，这使得开发人员能够更专注于业务逻辑的实现，而不是底层的基础设施。

Spring框架支持多种开发场景，包括企业级应用、Web应用、批处理任务等。Spring框架的模块化设计使得开发者可以根据需要选择使用不同的模块，这使得框架具有高度的灵活性和可扩展性。

配置示例

public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void addUser(User user) {
        userRepository.save(user);
    }
}

2.2 Spring的核心特性

Spring框架提供了多个核心特性，以下是一些主要的特性：

依赖注入（Dependency Injection, DI）：依赖注入是Spring的核心概念之一，它允许开发者将对象的依赖关系通过配置文件进行管理，而不是在代码中硬编码。这种方式使得对象之间的耦合度降低，增强了模块的独立性和可维护性。
```
public class UserService {
  private UserRepository userRepository;

  public UserService(UserRepository userRepository) {
      this.userRepository = userRepository;
  }

  public void addUser(User user) {
      userRepository.save(user);
  }
}
```

面向切面编程（Aspect-Oriented Programming, AOP）：面向切面编程允许开发者将横切关注点（如日志记录、事务管理、安全性等）从业务逻辑中分离出来，通过定义切面来实现。这种方式使得代码更加清晰，提高了代码的可维护性。

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
  @Bean
  public LoggingAspect loggingAspect() {
      return new LoggingAspect();
  }
}

@Aspect
public class LoggingAspect {
  @Before("execution(* com.example.service.*.*(..))")
  public void logBeforeJoinPoint(JoinPoint joinPoint) {
      System.out.println("Calling method: " + joinPoint.getSignature().getName());
  }
}

容器（Inversion of Control, IoC）：Spring容器负责实例化、配置和装配对象，这使得对象之间的依赖关系通过配置文件或注解进行管理。这种方式使得代码更加解耦，提高了代码的灵活性。
```
@Configuration
public class AppConfig {
  @Bean
  public UserRepository userRepository() {
      return new UserRepository();
  }
}
```
持久层支持：Spring框架提供了对多种持久层技术的支持，包括JDBC、MyBatis、Hibernate等。它通过数据访问对象（DAO）模式来简化数据库操作。
```
@Repository
public class UserRepository {
  public void save(User user) {
      // 实现数据库操作代码
  }
}
```

Web应用开发：Spring MVC是Spring框架中的一个子项目，它提供了基于MVC（Model-View-Controller）模式的Web应用开发支持。它允许开发者构建高效、可维护的Web应用。

@Controller
public class UserController {
  @Autowired
  private UserService userService;

  @GetMapping("/users")
  public String listUsers(Model model) {
      List<User> users = userService.getAllUsers();
      model.addAttribute("users", users);
      return "users";
  }
}

事务管理：Spring框架提供了方便的事务管理功能，允许开发者通过配置方式来管理事务。它支持多种事务管理器，包括JDBC、JPA、JTA等。
```
@Service
public class UserService {
  @Transactional
  public void addUser(User user) {
      // 插入用户到数据库
  }
}
```

2.3 第一个Spring项目

要构建第一个Spring项目，需要按照以下步骤进行：

创建一个新的Spring项目，可以使用Spring Initializr快速创建。
在项目中添加必要的依赖，例如Spring Boot Starter Web和Spring Boot Starter Data JPA。
配置Spring容器，定义Bean及其依赖关系。
编写业务逻辑代码。
运行并测试项目。

以下是一个简单的Spring项目示例：

创建Spring Boot项目
使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：
- Spring Boot Starter Web
- Spring Boot Starter Data JPA
- MySQL Driver

配置Spring容器
在application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

定义实体类
创建一个简单的用户实体类：

@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

定义Repository接口
创建一个简单的用户Repository接口：

public interface UserRepository extends JpaRepository<User, Long> {
}

定义Service类
创建一个用户Service类：

@Service
public class UserService {
   @Autowired
   private UserRepository userRepository;

   public User addUser(User user) {
       return userRepository.save(user);
   }
}

定义Controller类
创建一个用户Controller类：

@RestController
public class UserController {
   @Autowired
   private UserService userService;

   @PostMapping("/users")
   public User addUser(@RequestBody User user) {
       return userService.addUser(user);
   }
}

运行并测试项目
运行Spring Boot应用，并使用Postman或curl测试接口：

curl -X POST http://localhost:8080/users -H "Content-Type: application/json" -d '{"name":"John Doe", "email":"john@example.com"}'

通过以上步骤，可以构建一个简单的Spring项目，实现用户添加功能。

MyBatis框架入门

3.1 MyBatis简介

MyBatis是一个优秀的持久层框架，它允许开发者使用简单的XML或注解进行数据库操作。MyBatis的核心思想是将SQL语句映射到Java方法，通过配置文件或注解来管理这些映射关系。这种方式简化了数据库操作的复杂度，使得开发者能够更加专注于业务逻辑的实现。

MyBatis框架的核心组件包括SqlSession、Mapper接口、XML配置文件等。SqlSession是一个会话对象，负责执行数据库操作。Mapper接口定义了数据访问方法，而XML配置文件则定义了这些方法与SQL语句之间的映射关系。

3.2 MyBatis的配置与使用

要使用MyBatis框架，需要进行以下配置：

导入依赖
在项目中添加MyBatis和数据库驱动的依赖：

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

<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-core</artifactId>
   <version>2.14.1</version>
</dependency>

配置MyBatis
创建一个配置文件mybatis-config.xml，定义数据库连接信息和Mapper文件位置：

<configuration>
   <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="root"/>
           </dataSource>
       </environment>
   </environments>
   <mappers>
       <mapper resource="UserMapper.xml"/>
   </mappers>
</configuration>

定义Mapper接口
创建一个用户Mapper接口：

public interface UserMapper {
   User selectUserById(int id);
   void insertUser(User user);
}

编写Mapper XML配置文件
创建一个名为UserMapper.xml的XML文件，定义SQL语句与Mapper接口方法之间的映射关系：

<mapper namespace="com.example.mapper.UserMapper">
   <select id="selectUserById" resultType="com.example.model.User">
       SELECT id, name, email FROM users WHERE id = #{id}
   </select>
   <insert id="insertUser">
       INSERT INTO users (name, email) VALUES (#{name}, #{email})
   </insert>
</mapper>

使用SqlSession
在Java代码中通过SqlSession执行数据库操作：

public class UserDAO {
   private SqlSessionFactory sqlSessionFactory;

   public UserDAO(SqlSessionFactory sqlSessionFactory) {
       this.sqlSessionFactory = sqlSessionFactory;
   }

   public User selectUserById(int id) {
       try (SqlSession session = sqlSessionFactory.openSession()) {
           UserMapper mapper = session.getMapper(UserMapper.class);
           return mapper.selectUserById(id);
       }
   }

   public void insertUser(User user) {
       try (SqlSession session = sqlSessionFactory.openSession()) {
           UserMapper mapper = session.getMapper(UserMapper.class);
           mapper.insertUser(user);
           session.commit();
       }
   }
}

通过以上步骤，可以配置并使用MyBatis框架进行数据库操作。

3.3 MyBatis与数据库交互

MyBatis通过SQL语句与数据库进行交互，支持多种数据库操作，包括查询、插入、更新和删除。以下是一些常见操作的示例：

查询操作
使用select标签定义查询语句，并通过Mapper接口调用：

<select id="selectUserById" resultType="com.example.model.User">
   SELECT id, name, email FROM users WHERE id = #{id}
</select>

插入操作
使用insert标签定义插入语句，并通过Mapper接口调用：

<insert id="insertUser">
   INSERT INTO users (name, email) VALUES (#{name}, #{email})
</insert>

更新操作
使用update标签定义更新语句，并通过Mapper接口调用：

<update id="updateUserEmail">
   UPDATE users SET email = #{email} WHERE id = #{id}
</update>

删除操作
使用delete标签定义删除语句，并通过Mapper接口调用：
```
<delete id="deleteUserById">
   DELETE FROM users WHERE id = #{id}
</delete>
```

通过这些配置和代码示例，可以实现与数据库的交互操作。MyBatis框架提供了丰富的功能和灵活性，使得开发者能够高效地进行数据库操作。

Hibernate框架入门

4.1 Hibernate简介

Hibernate是一个流行的持久层框架，专注于对象关系映射（ORM）。它将Java对象映射到数据库表，并自动处理数据库的CRUD操作。Hibernate通过提供强大的映射工具和查询语言（HQL），简化了数据库操作的复杂度。

Hibernate框架的核心组件包括Session、Transaction、Entity和Mapping文件等。Session是持久层的会话对象，负责执行数据库操作。Entity表示数据库表中的记录，通过注解或XML文件映射到数据库表。Mapping文件定义了实体类与数据库表之间的映射关系。

4.2 Hibernate的基本概念

要使用Hibernate框架，需要了解一些基本概念：

Session: Session是Hibernate的持久层会话对象，负责与数据库进行交互。它是一个线程不安全的对象，需要通过SessionFactory创建。
SessionFactory: SessionFactory是SessionFactory接口的实现类，它负责创建Session对象。SessionFactory是线程安全的，可以被多个线程共享。
Transaction: Transaction表示一个数据库事务。在执行数据库操作之前，需要开启一个事务。操作完成后，需要提交事务。
Entity: Entity表示数据库表中的记录，通过注解或XML文件映射到数据库表。Entity类通常包含主键、属性和业务逻辑方法。
Mapping: Mapping文件定义了实体类与数据库表之间的映射关系。可以通过注解或XML文件进行配置。

4.3 Hibernate的简单应用

要使用Hibernate框架，需要进行以下步骤：

配置Hibernate
配置Hibernate连接到数据库，并生成映射文件。可以使用hibernate.cfg.xml文件进行配置：

<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">root</property>
       <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
       <property name="hibernate.hbm2ddl.auto">update</property>
       <mapping class="com.example.model.User"/>
   </session-factory>
</hibernate-configuration>

定义实体类
创建一个简单的用户实体类，并使用注解定义映射关系：

@Entity
@Table(name = "users")
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

定义DAO类
创建一个用户DAO类，使用Hibernate进行数据库操作：

public class UserDAO {
   private SessionFactory sessionFactory;

   public UserDAO(SessionFactory sessionFactory) {
       this.sessionFactory = sessionFactory;
   }

   public User selectUserById(int id) {
       try (Session session = sessionFactory.openSession()) {
           return session.get(User.class, id);
       }
   }

   public void insertUser(User user) {
       try (Session session = sessionFactory.openSession()) {
           session.beginTransaction();
           session.save(user);
           session.getTransaction().commit();
       }
   }
}

运行并测试项目
在主类中初始化SessionFactory，并创建UserDAO对象：

public class Main {
   public static void main(String[] args) {
       Configuration configuration = new Configuration();
       configuration.configure();

       ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
               .applySettings(configuration.getProperties()).build();
       SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

       UserDAO userDAO = new UserDAO(sessionFactory);

       User user = new User();
       user.setName("John Doe");
       user.setEmail("john@example.com");
       userDAO.insertUser(user);

       User retrievedUser = userDAO.selectUserById(1);
       System.out.println(retrievedUser.getName());
   }
}

通过以上步骤，可以使用Hibernate框架实现简单的数据库操作。

Struts框架入门

5.1 Struts简介

Struts是一个流行的MVC（Model-View-Controller）框架，用于构建Web应用。它提供了一套强大的标签库和配置工具，使得开发者能够更加高效地构建Web应用。Struts框架的核心组件包括Action、ActionForm、ActionServlet、ActionMapping等。

5.2 Struts项目搭建

要搭建一个Struts项目，需要进行以下步骤：

创建Struts项目
使用IDE创建一个新的Web项目，并添加Struts依赖。可以使用Maven或手动添加依赖：

<!-- Maven -->
<dependency>
   <groupId>org.apache.struts</groupId>
   <artifactId>struts2-core</artifactId>
   <version>2.5.20</version>
</dependency>

配置struts.xml
创建一个struts.xml文件，定义Action和ActionMapping：

<struts>
   <package name="default" namespace="/" extends="struts-default">
       <action name="login" class="com.example.web.LoginAction">
           <result name="success">/success.jsp</result>
           <result name="input">/login.jsp</result>
       </action>
   </package>
</struts>

创建Action类
创建一个简单的LoginAction类：

public class LoginAction extends ActionSupport {
   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;
   }

   public String execute() {
       if ("admin".equals(username) && "admin".equals(password)) {
           return SUCCESS;
       } else {
           return INPUT;
       }
   }
}

创建JSP页面
创建登录页面login.jsp和成功页面success.jsp：

<!-- login.jsp -->
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
   <title>Login Page</title>
</head>
<body>
   <h1>Login</h1>
   <s:form action="login">
       <s:textfield name="username" label="Username"/>
       <s:password name="password" label="Password"/>
       <s:submit value="Login"/>
   </s:form>
</body>
</html>

<!-- success.jsp -->
<html>
<head>
   <title>Success Page</title>
</head>
<body>
   <h1>Login Successful!</h1>
</body>
</html>

运行并测试项目
启动应用服务器，并访问登录页面。输入正确的用户名和密码，查看是否成功跳转到成功页面。

通过以上步骤，可以搭建一个简单的Struts项目，并实现基本的登录功能。

5.3 Struts的基本流程

Struts框架的核心流程包括Action、ActionForm和ActionServlet等组件。以下是一个简单的流程示例：

ActionServlet
ActionServlet是Struts框架的核心Servlet，负责处理HTTP请求。当用户提交表单时，请求会先发送到ActionServlet。
ActionMapping
ActionMapping定义了Action及其对应的请求URL。它通过struts.xml文件进行配置。
ActionForm
ActionForm是一个JavaBean，用于封装表单数据。ActionServlet会将表单数据绑定到ActionForm对象上。
Action
Action是一个Java类，用于处理业务逻辑。ActionServlet会根据请求URL调用相应的Action方法。Action方法返回一个字符串，表示请求处理的结果。
结果页面
根据Action方法返回的结果，ActionServlet会跳转到相应的JSP页面。例如，如果Action方法返回"success"，ActionServlet会跳转到对应的成功页面。

通过以上流程，可以实现MVC模式下的Web应用开发。

实战案例：整合Spring与MyBatis

6.1 项目需求分析

假设我们需要开发一个简单的用户管理系统，该系统需要支持用户注册和登录功能。我们可以使用Spring框架进行业务逻辑处理，使用MyBatis进行数据库操作。

6.2 项目环境搭建

要搭建项目环境，需要进行以下步骤：

创建Spring Boot项目
使用Spring Initializr创建一个新的Spring Boot项目，并添加以下依赖：
- Spring Boot Starter Web
- Spring Boot Starter Data MyBatis
- MySQL Driver

配置Spring容器
在application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

定义实体类
创建一个简单的用户实体类：

@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

定义Mapper接口
创建一个用户Mapper接口：

public interface UserMapper {
   User selectUserById(int id);
   void insertUser(User user);
}

编写Mapper XML配置文件
创建一个名为UserMapper.xml的XML文件，定义SQL语句与Mapper接口方法之间的映射关系：

<mapper namespace="com.example.mapper.UserMapper">
   <select id="selectUserById" resultType="com.example.model.User">
       SELECT id, name, email FROM users WHERE id = #{id}
   </select>
   <insert id="insertUser">
       INSERT INTO users (name, email) VALUES (#{name}, #{email})
   </insert>
</mapper>

定义Service类
创建一个用户Service类：

@Service
public class UserService {
   private final UserMapper userMapper;

   public UserService(UserMapper userMapper) {
       this.userMapper = userMapper;
   }

   public User addUser(User user) {
       return userMapper.insertUser(user);
   }
}

定义Controller类
创建一个用户Controller类：

@RestController
public class UserController {
   @Autowired
   private UserService userService;

   @PostMapping("/users")
   public User addUser(@RequestBody User user) {
       return userService.addUser(user);
   }
}

通过以上步骤，可以搭建一个简单的Spring Boot项目，并配置Spring容器和MyBatis。

6.3 代码实现与调试

要实现用户注册和登录功能，需要进行以下步骤：

实现注册功能
在UserController中实现用户注册方法：

@RestController
public class UserController {
   @Autowired
   private UserService userService;

   @PostMapping("/users")
   public User addUser(@RequestBody User user) {
       return userService.addUser(user);
   }
}

实现登录功能
创建一个新的LoginController类，实现用户登录方法：

@RestController
public class LoginController {
   @Autowired
   private UserService userService;

   @GetMapping("/users/{id}")
   public User getUserById(@PathVariable int id) {
       return userService.getUserById(id);
   }
}

调试和测试
启动项目，使用Postman或curl测试接口。例如，注册一个新用户：

curl -X POST http://localhost:8080/users -H "Content-Type: application/json" -d '{"name":"John Doe", "email":"john@example.com"}'

通过以上步骤，可以实现用户注册和登录功能，并进行调试和测试。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

LEATH

手记
篇

粉丝

93

获赞与收藏

467

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19278 315

Java 并发原理入门教程

26个小节 39003 568

Java 入门教程

50个小节 342046 3165

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空