首頁手記 Java主流框架學習：從入門到實踐指南

Java主流框架學習：從入門到實踐指南

標簽：

Java SpringBoot Spring

概述

本文介绍了Java主流框架学习的相关内容，涵盖Spring、MyBatis、Hibernate和Struts等框架的基本概念、配置方法及应用场景。这些框架在现代软件开发中扮演着至关重要的角色，提供了强大的工具和库，帮助开发者构建高效、可维护且易于扩展的Java应用程序。Spring框架提供依赖注入、事务管理和Web MVC等功能；MyBatis简化数据库操作；Hibernate支持对象-关系映射（ORM）；Struts专注于MVC模式的实现。通过实战练习和项目实践，开发者可以更好地掌握这些框架的使用技巧，并解决开发过程中的常见问题。Java主流框架学习不仅能够提高开发效率，还能增强代码的可维护性和扩展性。对于构建高效、可维护的Java应用程序而言，Java主流框架学习至关重要。

Java主流框架概述

Java主流框架在现代软件开发中扮演着至关重要的角色，它们提供了强大的工具和库，帮助开发者构建高效、可维护且易于扩展的Java应用程序。这些框架不仅简化了开发过程，还提供了广泛的功能，例如数据库操作、Web服务、依赖注入、事务管理等。下面将介绍一些Java主流框架及其应用场景：

Spring框架：Spring是一个企业级应用开发框架，提供依赖注入、事务管理、Web MVC等功能。Spring框架简化了企业级应用开发，提供了大量的基础框架和库，帮助开发者更高效地进行开发。
MyBatis框架：MyBatis是一个持久层框架，专注于简化数据库操作。MyBatis通过XML配置文件或注解来映射数据库表与Java对象之间的关系，使得开发者可以直接操作数据库，而无需编写复杂的SQL语句。
Hibernate框架：Hibernate也是一个持久层框架，提供了对象-关系映射（ORM）功能。Hibernate可以将Java对象映射到数据库表，简化了数据库操作，并提供了事务管理和缓存等高级功能。
Struts框架：Struts是一个Web开发框架，专注于MVC（Model-View-Controller）模式的实现。Struts框架帮助开发者构建结构化、模块化的Web应用程序，支持多种视图技术，如JSP、FreeMarker等。

Spring框架入门

Spring框架是一个广泛使用的Java应用开发框架，它提供了丰富的功能模块，如依赖注入、事务管理、Web MVC等。Spring框架旨在简化企业级Java应用程序的开发，它通过提供基础框架和库来促进高效开发。本节将详细介绍Spring框架的基本概念、核心功能和组件，并通过一个简单的实例来演示如何使用Spring框架。

Spring框架的基本概念

Spring框架的核心思想是“依赖注入”（Dependency Injection，简称DI）和“面向切面编程”（Aspect-Oriented Programming，简称AOP）。依赖注入是Spring的核心机制，它允许开发者将对象的依赖关系从代码中解耦，通过配置文件或注解来管理对象之间的依赖关系。面向切面编程则是通过将程序中的横切关注点（如日志、事务管理等）抽离出来，形成切面，从而提高代码的可维护性和复用性。

Spring框架分为多个模块，每个模块负责不同的功能，例如Spring Core（核心模块）、Spring Context（上下文模块）、Spring Web（Web模块）等。通过这些模块，开发者可以灵活地选择和组合所需的功能，构建出完整的应用系统。

Spring框架的核心功能和组件

Spring框架提供了多种核心功能和组件，包括：

依赖注入：Spring框架通过DI机制，将对象的依赖关系从代码中解耦，通过配置文件或注解来管理对象之间的依赖关系。这使得代码更加模块化和可测试。
事务管理：Spring框架提供了一套强大的事务管理机制，支持声明式事务管理，可以通过注解或配置文件来定义事务边界，简化事务处理。
Web MVC：Spring Web MVC模块提供了Model-View-Controller（MVC）模式实现，支持多种视图技术，如JSP、Thymeleaf、FreeMarker等，帮助开发者构建结构化、模块化的Web应用程序。
数据访问：Spring框架提供了多种数据访问机制，如JDBC、Hibernate、MyBatis等，支持多种数据库操作，简化了数据访问层的开发。

Spring框架的简单实例

下面通过一个简单的实例来演示如何使用Spring框架。这个实例将展示如何通过Spring框架实现一个简单的“Hello World”程序，并通过依赖注入来管理对象之间的依赖关系。

首先，创建一个简单的Java类HelloWorld，表示一个简单的“Hello World”程序。

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void printHello() {
        System.out.println("Hello World! " + message);
    }
}

接下来，创建一个Spring配置文件applicationContext.xml，使用<bean>标签来定义HelloWorld对象，并通过<property>标签设置其依赖关系。

<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="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello from Spring!"></property>
    </bean>
</beans>

最后，创建一个Java类App，通过Spring的ApplicationContext来获取HelloWorld对象，并调用其方法打印消息。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.printHello();
    }
}

运行上述代码，将输出以下结果：

Hello World! Hello from Spring!

MyBatis框架入门

MyBatis是一个持久层框架，专注于简化数据库操作，通过XML配置文件或注解来映射数据库表与Java对象之间的关系。MyBatis框架帮助开发者直接操作数据库，而无需编写复杂的SQL语句，提高了开发效率和代码的可维护性。本节将详细介绍MyBatis框架的基本概念、配置和使用方法，并通过一个简单的实例来演示如何使用MyBatis框架。

MyBatis框架的基本概念

MyBatis框架的核心思想是“SQL映射”，即通过XML配置文件或注解将数据库表与Java对象之间的关系进行映射。这种方式使得开发者可以直接操作数据库，而无需编写复杂的SQL语句。MyBatis框架提供了强大的查询映射功能，支持多种数据库操作，如插入、更新、查询等。

MyBatis框架由多个组件构成，包括SqlSessionFactory、SqlSession、Mapper接口等。SqlSessionFactory负责创建SqlSession对象，SqlSession对象用于执行SQL语句和处理结果集，Mapper接口则定义了数据库操作的接口。

MyBatis框架的配置和使用

MyBatis框架的配置主要包括以下几个步骤：

配置文件：MyBatis框架使用XML配置文件或注解来定义数据库连接和SQL映射规则。XML配置文件通常命名为mybatis-config.xml，包含数据库连接信息、类型别名、映射文件等配置。注解配置则通过Java注解来定义SQL映射规则，适用于简单的应用场景。
映射文件：映射文件用于定义SQL语句和Java对象之间的映射规则。映射文件通常命名为UserMapper.xml，包含SQL语句、结果映射等配置。在映射文件中，可以通过<select>、<insert>、<update>、<delete>等标签来定义SQL语句，并通过<resultMap>标签来定义结果映射规则。
Mapper接口：Mapper接口定义了数据库操作的接口，每个方法对应一个SQL语句。通过MyBatis提供的注解（如@Select、@Insert等）来定义SQL语句和映射规则。

MyBatis框架的简单实例

下面通过一个简单的实例来演示如何使用MyBatis框架。这个实例将展示如何通过MyBatis框架实现一个简单的用户管理程序，包括用户查询、插入、更新和删除操作。

创建一个简单的Java类User，表示用户对象。

public class User {
    private int id;
    private String name;
    private String email;
    // getters and setters
}

创建一个Mapper接口UserMapper，定义用户管理的接口。

public interface UserMapper {
    List<User> selectAllUsers();
    User selectUserById(int id);
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

创建一个XML映射文件UserMapper.xml，定义SQL语句和结果映射规则。

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectAllUsers" resultType="com.example.model.User">
        SELECT * FROM users
    </select>
    <select id="selectUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <insert id="insertUser">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
    <update id="updateUser">
        UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id = #{id}
    </delete>
</mapper>

创建一个Spring配置文件applicationContext.xml，定义MyBatis配置和Mapper接口。

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

    <mybatis:sqlSessionFactory id="sqlSessionFactory">
        <mybatis:configuration>
            <mybatis:environments default="development">
                <mybatis:environment id="development">
                    <mybatis:transactionManager type="JDBC"/>
                    <mybatis:dataSource type="POOLED">
                        <mybatis:property name="driver" value="com.mysql.jdbc.Driver"/>
                        <mybatis:property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                        <mybatis:property name="username" value="root"/>
                        <mybatis:property name="password" value="password"/>
                    </mybatis:datasource>
                </mybatis:environment>
            </mybatis:environments>
            <mybatis:mappers>
                <mybatis:mapper resource="com/example/mapper/UserMapper.xml"/>
            </mybatis:mappers>
        </mybatis:configuration>
    </mybatis:sqlSessionFactory>

    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.mapper"/>
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

创建一个Java类App，通过Spring的ApplicationContext来获取Mapper接口，并调用其方法进行数据库操作。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean(UserMapper.class);
        JdbcTemplate jdbcTemplate = new JdbcTemplate((DataSource) context.getBean("dataSource"));

        // 查询所有用户
        System.out.println("All Users:");
        List<User> users = userMapper.selectAllUsers();
        for (User user : users) {
            System.out.println(user);
        }

        // 插入新用户
        User newUser = new User();
        newUser.setName("John Doe");
        newUser.setEmail("[email protected]");
        userMapper.insertUser(newUser);

        // 更新用户信息
        User updateUser = new User();
        updateUser.setId(1);
        updateUser.setName("Jane Doe");
        updateUser.setEmail("[email protected]");
        userMapper.updateUser(updateUser);

        // 删除用户
        userMapper.deleteUser(1);
    }
}

Hibernate框架入门

Hibernate框架是一个持久层框架，专注于对象-关系映射（ORM），将Java对象映射到数据库表。Hibernate框架简化了数据库操作，提供了事务管理和缓存等高级功能。本节将详细介绍Hibernate框架的基本概念、配置和使用方法，并通过一个简单的实例来演示如何使用Hibernate框架。

Hibernate框架的基本概念

Hibernate框架的核心思想是“对象-关系映射”（ORM），它通过映射规则将Java对象映射到数据库表。Hibernate框架提供了丰富的功能，如事务管理、缓存等，帮助开发者简化数据库操作。

Hibernate框架由多个组件构成，包括SessionFactory、Session、Transaction等。SessionFactory负责创建Session对象，Session对象用于执行SQL语句和处理结果集，Transaction则用于管理事务边界。

Hibernate框架的配置和使用

Hibernate框架的配置主要包括以下几个步骤：

配置文件：Hibernate框架使用XML配置文件或注解来定义数据库连接和映射规则。XML配置文件通常命名为hibernate.cfg.xml，包含数据库连接信息、映射文件等配置。注解配置则通过Java注解来定义映射规则，适用于简单的应用场景。
映射文件：映射文件用于定义Java对象和数据库表之间的映射规则。映射文件通常命名为User.hbm.xml，包含类名、属性名等配置。在映射文件中，可以通过<class>标签来定义类信息，并通过<property>标签来定义属性信息。
映射注解：通过Java注解来定义映射规则，适用于简单的应用场景。常用的注解包括@Entity、@Table、@Id、@Column等。

Hibernate框架的简单实例

下面通过一个简单的实例来演示如何使用Hibernate框架。这个实例将展示如何通过Hibernate框架实现一个简单的用户管理程序，包括用户查询、插入、更新和删除操作。

创建一个简单的Java类User，表示用户对象，并使用Java注解定义映射规则。

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

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

    // getters and setters
}

创建一个Spring配置文件applicationContext.xml，定义Hibernate配置。

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

    <context:component-scan base-package="com.example"/>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.example.model"/>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>

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

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

创建一个Java类UserDAO，实现用户管理的接口。

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Repository
public class UserDAO {
    @Autowired
    private SessionFactory sessionFactory;

    @Transactional
    public List<User> getAllUsers() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("FROM User").list();
    }

    @Transactional
    public User getUserById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(User.class, id);
    }

    @Transactional
    public void addUser(User user) {
        Session session = sessionFactory.getCurrentSession();
        session.save(user);
    }

    @Transactional
    public void updateUser(User user) {
        Session session = sessionFactory.getCurrentSession();
        session.update(user);
    }

    @Transactional
    public void deleteUser(int id) {
        Session session = sessionFactory.getCurrentSession();
        User user = session.get(User.class, id);
        if (user != null) {
            session.delete(user);
        }
    }
}

创建一个Java类App，通过Spring的ApplicationContext来获取DAO接口，并调用其方法进行数据库操作。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDAO userDAO = context.getBean(UserDAO.class);

        // 查询所有用户
        System.out.println("All Users:");
        List<User> users = userDAO.getAllUsers();
        for (User user : users) {
            System.out.println(user);
        }

        // 插入新用户
        User newUser = new User();
        newUser.setName("John Doe");
        newUser.setEmail("[email protected]");
        userDAO.addUser(newUser);

        // 更新用户信息
        User updateUser = new User();
        updateUser.setId(1);
        updateUser.setName("Jane Doe");
        updateUser.setEmail("[email protected]");
        userDAO.updateUser(updateUser);

        // 删除用户
        userDAO.deleteUser(1);
    }
}

Struts框架入门

Struts框架是一个Web开发框架，专注于Model-View-Controller（MVC）模式的实现。Struts框架帮助开发者构建结构化、模块化的Web应用程序，支持多种视图技术，如JSP、FreeMarker等。本节将详细介绍Struts框架的基本概念、配置和使用方法，并通过一个简单的实例来演示如何使用Struts框架。

Struts框架的基本概念

Struts框架的核心思想是MVC模式，它将应用程序分为三个层次：Model、View和Controller。MVC模式通过将程序逻辑和界面展示分离，使得代码更加模块化和可维护。

Model：模型层负责数据的存储和逻辑处理。
View：视图层负责界面展示，如JSP页面、FreeMarker模板等。
Controller：控制器层负责处理用户的请求，协调模型和视图之间的交互。

Struts框架提供了丰富的功能和组件，如表单验证、国际化支持、标签库等，帮助开发者构建功能丰富的Web应用程序。

Struts框架的配置和使用

Struts框架的配置主要包括以下几个步骤：

配置文件：Struts框架使用XML配置文件struts.xml来定义应用程序的配置信息，包括Action、ActionForm、Interceptor等配置。
Action类：Action类负责处理用户的请求，协调模型和视图之间的交互。Action类通过实现Action接口或继承ActionSupport类来实现。
ActionForm类：ActionForm类负责封装表单数据，通过实现ActionForm接口或继承ActionForm类来实现。
视图页面：视图页面负责界面展示，如JSP页面、FreeMarker模板等。Struts框架提供了丰富的标签库，帮助开发者构建功能丰富的Web页面。

Struts框架的简单实例

下面通过一个简单的实例来演示如何使用Struts框架。这个实例将展示如何通过Struts框架实现一个简单的用户登录程序，包括用户查询、登录和退出操作。

创建一个User类，表示用户对象。

public class User {
    private String name;
    private String password;

    // getters and setters
}

创建一个LoginAction类，实现用户登录的逻辑。

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {
    private User user;
    private String message;

    public String execute() {
        // 用户登录逻辑
        if ("admin".equals(user.getName()) && "password".equals(user.getPassword())) {
            message = "登录成功！";
            return SUCCESS;
        } else {
            message = "登录失败！";
            return INPUT;
        }
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public String getMessage() {
        return message;
    }
}

创建一个LoginActionForm类，封装表单数据。

import com.opensymphony.xwork2.validator.ValidationAwareSupport;

public class LoginActionForm extends ValidationAwareSupport {
    private String name;
    private String password;

    // getters and setters
}

创建一个struts.xml配置文件，定义Action和ActionForm的映射关系。

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

创建一个login.jsp视图页面，用于用户输入登录信息。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title>Login</title>
</head>
<body>
<s:form action="login">
    <s:textfield name="user.name" label="用户名"/>
    <s:password name="user.password" label="密码"/>
    <s:submit value="登录"/>
</s:form>
</body>
</html>

创建一个success.jsp视图页面，显示登录成功信息。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
<h2>登录成功！</h2>
</body>
</html>

创建一个input.jsp视图页面，显示登录失败信息。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Login Fail</title>
</head>
<body>
<h2>登录失败！</h2>
</body>
</html>

运行上述代码，将执行以下操作：

用户在login.jsp页面输入登录信息；
LoginAction类处理用户的登录请求，根据用户名和密码是否匹配返回不同的结果；
根据不同的结果跳转到success.jsp或input.jsp页面。

实战练习与项目实践

在掌握了Java主流框架的基本概念和使用方法后，接下来需要通过实际项目开发来巩固所学知识，提高实际开发能力。通过实战练习和项目实践，可以更好地理解框架的高级特性和最佳实践，解决开发过程中遇到的常见问题。

使用主流框架进行实际项目开发

在实际项目开发中，可以选择一个具体的应用场景，如电子商务网站、社交网络、企业管理系统等。根据应用场景选择合适的框架组合，如Spring + Hibernate、Spring + MyBatis、Struts + Hibernate等，构建出完整的应用系统。在开发过程中，需要考虑以下几个方面：

需求分析：明确项目需求，定义系统的功能模块和数据模型。
架构设计：设计系统的整体架构，选择合适的框架组合和开发工具。
模块开发：按照架构设计进行模块开发，实现各个功能模块的逻辑处理。
测试调试：进行单元测试、集成测试和性能测试，确保系统的稳定性和可靠性。
部署上线：将系统部署到生产环境，进行上线前的最后调试和优化。

项目开发中的常见问题与解决方法

在项目开发过程中，可能会遇到一些常见的问题，如依赖关系复杂、事务管理困难、性能瓶颈等。下面列举几个常见的问题及解决方法：

依赖关系复杂：在使用多个框架组合进行开发时，可能会遇到依赖关系复杂的问题。可以通过以下方法解决：
- 依赖注入：通过Spring框架的依赖注入功能，将对象的依赖关系从代码中解耦，通过配置文件或注解来管理对象之间的依赖关系。
- 模块化设计：将系统划分为多个模块，每个模块负责一个功能，通过模块之间的接口进行交互，降低模块之间的耦合度。
事务管理困难：在涉及数据库操作时，可能会遇到事务管理困难的问题。可以通过以下方法解决：
- 声明式事务管理：通过Spring框架的声明式事务管理功能，通过配置文件或注解来定义事务边界，简化事务处理。
- 编程式事务管理：通过编程方式定义事务边界，通过代码来控制事务的开始、提交和回滚。
性能瓶颈：在高并发环境下，可能会遇到性能瓶颈的问题。可以通过以下方法解决：
- 缓存机制：通过使用缓存机制，减少数据库访问次数，提高系统性能。
- 数据库优化：通过优化数据库表结构、索引、查询语句等，提高数据库访问性能。

通过实战练习和项目实践，可以更好地掌握Java主流框架的使用方法和最佳实践，提高实际开发能力。推荐的学习资源包括慕课网（http://www.xianlaiwan.cn/）等在线教育平台，这些平台提供了丰富的实战项目和课程，帮助开发者提升技能。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

慕容3067478

手記
篇

粉絲

3

獲贊與收藏

21

關注作者，訂閱最新文章

閱讀免費教程

Java并發工具

23個小節 19844 321

Java 并發原理入門教程

26個小節 40021 580

Java 入門教程

50個小節 351793 3256

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空