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

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

标签：

Java Spring Cloud SSM

概述

本文介绍了Java主流框架学习的相关内容，包括Spring、MyBatis、Hibernate和Struts等框架的基本概念和使用方法。通过实际案例和配置示例，详细讲解了这些框架在项目中的应用和配置方式，帮助读者更好地理解和掌握Java主流框架学习。

Java主流框架概述

框架的概念与分类

在软件开发中，框架（Framework）是一种半成品软件，它主要为特定的软件类别提供通用解决方案。框架通过提供一个预定义的结构，让开发者只需填充某些特定的部分，即可快速构建出完整的应用。框架可以分为多种类型，例如MVC（Model-View-Controller）、ORM（Object-Relational Mapping）以及Web框架等。

常见Java框架介绍

Java拥有丰富的框架生态，以下是一些常见的Java框架：

Spring框架：Spring是一个开源的Java平台，它通过提供一系列功能模块来简化Java应用程序的开发。Spring框架主要目标是简化企业应用程序开发，并通过依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）来提高代码的可维护性。
MyBatis框架：MyBatis是一个持久层框架，它简化了数据库操作，使得开发人员可以通过简单的配置文件来操作数据库。MyBatis主要通过XML或注解来配置SQL语句，从而将SQL语句映射到Java对象。
Hibernate框架：Hibernate是一个ORM框架，它允许开发人员使用面向对象的编程方式来操作数据库，而不需要编写大量的SQL代码。Hibernate使用映射文件或注解来定义Java对象与数据库表之间的映射关系。
Struts框架：Struts是MVC框架，它用于构建Java Web应用程序。Struts通过控制器（ActionServlet）来处理用户请求，将请求分发给相应的Action处理，并根据Action的处理结果选择对应的视图（JSP页面）进行渲染。

Spring框架入门

Spring框架简介

Spring框架是Spring开源组织的核心产品，它是一系列框架的集合，旨在简化企业应用程序的开发。Spring的核心模块是Spring Core，它提供了一种依赖注入（Dependency Injection, DI）的模式，使得Java对象之间的依赖关系可以被外部配置，并且可以在运行时动态地注入到对象中。Spring框架还提供了面向切面编程（Aspect-Oriented Programming, AOP）的支持，使得开发人员可以将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来。

Spring框架的主要优点包括：

依赖注入：通过DI，开发人员可以将对象之间的依赖关系从代码中解耦，从而提高代码的可维护性和可测试性。
AOP支持：通过AOP，开发人员可以将横切关注点从业务逻辑中分离出来，从而提高代码的可复用性和可维护性。
面向切面编程：Spring还支持面向切面编程（AOP），可以将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，从而提高代码的可复用性和可维护性。
容器管理：Spring框架提供了容器管理的功能，可以自动地创建、配置和管理Java对象的生命周期。

Spring基本配置与使用

Spring的XML配置

Spring框架可以通过XML配置文件来定义Java对象之间的依赖关系。下面是一个简单的Spring XML配置文件示例，以及对应的Java对象示例代码：

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

    <bean id="userService" class="com.example.UserService" />

</beans>

// UserService.java
package com.example;

public class UserService {
    public void addUser() {
        System.out.println("User added.");
    }
}

在这个示例中，UserService类是一个Java对象，它被定义为一个Spring Bean。通过<bean>标签，可以定义该对象的ID和类名。在实际开发中，可以通过Spring容器来获取这个对象，并调用其方法。

Spring的注解配置

除了XML配置，Spring框架还支持使用注解来定义Java对象之间的依赖关系。下面是一个简单的Spring注解配置示例，以及对应的Java对象示例代码：

// UserService.java
package com.example;

import org.springframework.stereotype.Component;

@Component
public class UserService {
    public void addUser() {
        System.out.println("User added.");
    }
}

// Main.java
package com.example;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean(UserService.class);
        userService.addUser();
    }
}

在这个示例中，通过@Component注解，可以将UserService类定义为一个Spring Bean。通过ApplicationContext，可以获取这个对象，并调用其方法。

Spring的AOP支持

Spring框架还提供了AOP的支持，可以将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来。下面是一个简单的Spring AOP示例，以及对应的Java对象示例代码：

// UserService.java
package com.example;

public class UserService {
    public void addUser() {
        System.out.println("User added.");
    }
}

// LoggingAspect.java
package com.example;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

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

// Main.java
package com.example;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean(UserService.class);
        userService.addUser();
    }
}

在这个示例中，通过@Aspect注解，可以定义一个AOP切面，并通过@Before注解，可以在指定的方法执行之前插入日志记录的功能。通过ApplicationContext，可以获取到UserService对象，并调用其方法。

MyBatis框架入门

MyBatis简介

MyBatis是一个持久层框架，它简化了数据库操作，使得开发人员可以通过简单的配置文件来操作数据库。MyBatis主要通过XML或注解来配置SQL语句，从而将SQL语句映射到Java对象。MyBatis支持JDBC、JNDI、JPA等数据源，可以方便地连接各种数据库。

MyBatis支持两种方式来配置SQL语句：XML配置和注解配置。XML配置方式更适合复杂的SQL语句，因为它可以将SQL语句与Java对象之间的映射关系清晰地表示出来。注解配置方式更适合简单的SQL语句，因为它可以将SQL语句直接写在Java对象的方法注解中。

MyBatis的基本用法

XML配置

下面是MyBatis的XML配置示例，以及对应的Java对象示例代码：

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

// User.java
package com.example;

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

// UserMapper.java
package com.example.mapper;

import com.example.User;

public interface UserMapper {
    User getUserById(int id);
}

在这个示例中，通过<mapper>标签，可以定义一个SQL映射文件。通过<select>标签，可以定义一条SQL查询语句，并通过id属性来指定这条查询语句的唯一标识符。通过resultType属性，可以指定这条查询语句返回的结果类型。通过#{id}占位符，可以将参数值传递给SQL语句。通过UserMapper接口，可以定义一个Java对象的映射关系，并通过getUserById方法来调用SQL查询语句。

注解配置

除了XML配置，MyBatis还支持使用注解来配置SQL语句。下面是一个简单的MyBatis注解配置示例，以及对应的Java对象示例代码：

// UserMapper.java
package com.example.mapper;

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

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

// User.java
package com.example;

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

在这个示例中，通过@Select注解，可以定义一条SQL查询语句，并通过#{id}占位符，将参数值传递给SQL语句。通过UserMapper接口，可以定义一个Java对象的映射关系，并通过getUserById方法来调用SQL查询语句。

MyBatis的动态SQL

MyBatis支持动态SQL，可以动态地生成SQL语句。下面是一个简单的MyBatis动态SQL示例，以及对应的Java对象示例代码：

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
        <if test="name != null">
            AND name = #{name}
        </if>
    </select>
</mapper>

在这个示例中，通过<if>标签，可以定义一个动态SQL语句。通过test属性，可以指定一个条件表达式，当这个条件表达式为真时，才会执行对应的SQL语句。通过这种方式，可以根据不同的参数值，动态地生成不同的SQL语句。

Hibernate框架入门

Hibernate简介

Hibernate是一个持久层框架，它允许开发人员使用面向对象的编程方式来操作数据库，而不需要编写大量的SQL代码。Hibernate使用映射文件或注解来定义Java对象与数据库表之间的映射关系，并通过HQL（Hibernate Query Language）来执行数据库操作。

Hibernate的优势在于它可以将Java对象与数据库表之间的映射关系抽象出来，使得开发人员可以使用面向对象的方式来进行数据库操作。同时，Hibernate还提供了缓存、事务管理等功能，使得开发人员可以更加方便地管理数据库操作。

Hibernate的基本使用

Hibernate的配置

下面是Hibernate的配置示例，以及对应的Java对象示例代码：

<!-- hibernate.cfg.xml -->
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.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.MySQLDialect</property>
        <mapping class="com.example.User" />
    </session-factory>
</hibernate-configuration>

// User.java
package com.example;

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;
    // getters and setters
}

在这个示例中，通过<hibernate-configuration>标签，可以定义一个Hibernate配置文件。通过<property>标签，可以定义Hibernate的配置属性。通过<mapping>标签，可以定义一个Java对象的映射关系。通过@Entity注解，可以将User类定义为一个Hibernate实体类。通过@Id注解，可以定义一个唯一标识符属性。通过@GeneratedValue注解，可以定义一个自增属性。

Hibernate的映射

此外，Hibernate还支持使用映射文件来定义Java对象与数据库表之间的映射关系。下面是一个简单的Hibernate映射示例，以及对应的Java对象示例代码：

<!-- User.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.User" table="users">
        <id name="id" column="id" type="int" />
        <generator class="native" />
        <property name="name" column="name" type="string" />
        <property name="email" column="email" type="string" />
    </class>
</hibernate-mapping>

在这个示例中，通过<hibernate-mapping>标签，可以定义一个Hibernate映射文件。通过<class>标签，可以定义一个Java对象的映射关系。通过<id>标签，可以定义一个唯一标识符属性。通过<generator>标签，可以定义一个自增属性。通过<property>标签，可以定义一个普通属性。

Hibernate的HQL

Hibernate还支持使用HQL（Hibernate Query Language）来执行数据库操作。下面是一个简单的Hibernate HQL示例，以及对应的Java对象示例代码：

// User.java
package com.example;

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;
    // getters and setters
}

// Main.java
package com.example;

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

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

        User user = new User();
        user.setName("John");
        user.setEmail("john@example.com");
        session.save(user);

        tx.commit();
        session.close();
        sessionFactory.close();
    }
}

在这个示例中，通过Session对象，可以获取到一个Hibernate会话。通过Transaction对象，可以管理一个数据库事务。通过save方法，可以将一个Java对象保存到数据库中。

Struts框架入门

Struts简介

Struts是MVC框架，它用于构建Java Web应用程序。Struts通过控制器（ActionServlet）来处理用户请求，将请求分发给相应的Action处理，并根据Action的处理结果选择对应的视图（JSP页面）进行渲染。

Struts的主要优点包括：

MVC模式：Struts框架实现了MVC模式，将模型、视图和控制器分离，使得开发人员可以更加清晰地组织代码结构。
标签库：Struts框架提供了一套丰富的标签库，使得开发人员可以更加方便地创建动态的Web页面。
插件支持：Struts框架支持插件，可以方便地扩展框架的功能。

Struts的基本配置与使用

Struts的配置

下面是Struts的配置示例，以及对应的Java对象示例代码：

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

// LoginAction.java
package com.example;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {
    private String username;
    private String password;
    private UserService userService;

    public String execute() {
        userService.login();
        if (userService.isLoggedIn()) {
            return "success";
        } else {
            return "error";
        }
    }

    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 UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

<!-- login.jsp -->
<form action="login">
    Username: <input type="text" name="username" />
    Password: <input type="password" name="password" />
    <input type="submit" value="Login" />
</form>

在上面的示例中，通过<struts>标签，可以定义一个Struts配置文件。通过<package>标签，可以定义一个Struts包。通过<action>标签，可以定义一个Action处理。通过<result>标签，可以定义一个Action处理的返回结果。通过LoginAction类，可以定义一个Action处理。通过execute方法，可以处理用户请求。通过login.jsp页面，可以渲染一个登录表单。

Struts的标签库

Struts框架提供了一套丰富的标签库，使得开发人员可以更加方便地创建动态的Web页面。下面是一个简单的Struts标签库示例，以及对应的Java对象示例代码：

<!-- success.jsp -->
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title>Success</title>
</head>
<body>
    <h1>Success</h1>
    <s:property value="username" />
</body>
</html>

在上面的示例中，通过<%@ taglib %>标签，可以引入Struts标签库。通过<s:property>标签，可以获取到一个Action处理的属性值。

Struts的插件支持

Struts框架支持插件，可以方便地扩展框架的功能。下面是一个简单的Struts插件示例，以及对应的Java对象示例代码：

<!-- struts.xml -->
<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="login" class="com.example.LoginAction">
            <result name="success">/success.jsp</result>
            <result name="error">/error.jsp</result>
        </action>
    </package>
    <plugin class="com.example.MyPlugin" />
</struts>

// MyPlugin.java
package com.example;

import com.opensymphony.xwork2.config.Configuration;
import com.opensymphony.xwork2.config.ConfigurationProvider;

public class MyPlugin implements ConfigurationProvider {
    @Override
    public void init(Configuration configuration) {
        // initialization code
    }

    @Override
    public void destroy() {
        // cleanup code
    }
}

在上面的示例中，通过<plugin>标签，可以定义一个插件。通过MyPlugin类，可以定义一个插件的实现类。

实践项目与进阶

框架综合应用案例

通过前面的学习，我们已经了解了Spring、MyBatis、Hibernate和Struts等主流Java框架的基本概念和使用方法。接下来，我们将通过一个综合应用案例来进一步学习这些框架的使用。

假设我们正在开发一个简单的电商网站，该网站需要提供用户注册、登录、商品浏览、购物车管理和订单管理等功能。为了实现这个网站，我们将使用Spring、MyBatis、Hibernate和Struts框架。

首先，我们将使用Spring框架来管理Java对象的依赖关系。通过Spring框架，我们可以将用户服务、商品服务和订单服务等Java对象之间的依赖关系解耦，从而提高代码的可维护性和可测试性。同时，我们还将使用Spring框架的AOP支持，将日志记录、事务管理等横切关注点从业务逻辑中分离出来。

其次，我们将使用MyBatis框架来操作数据库。通过MyBatis框架，我们可以将SQL语句映射到Java对象，从而简化数据库操作。同时，我们还将使用MyBatis的动态SQL功能，根据不同的参数值，动态地生成不同的SQL语句。

再次，我们将使用Hibernate框架来操作数据库。通过Hibernate框架，我们可以将Java对象与数据库表之间的映射关系抽象出来，从而使用面向对象的方式来进行数据库操作。同时，我们还将使用Hibernate的缓存功能，提高数据库操作的效率。

最后，我们将使用Struts框架来构建Web应用程序。通过Struts框架，我们可以实现MVC模式，将模型、视图和控制器分离，从而清晰地组织代码结构。同时，我们还将使用Struts的标签库和插件支持，扩展框架的功能。

案例代码

下面是案例的代码示例：

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

    <bean id="userService" class="com.example.UserService" />
    <bean id="productService" class="com.example.ProductService" />
    <bean id="orderService" class="com.example.OrderService" />
</beans>

// UserService.java
package com.example;

import org.apache.ibatis.session.SqlSession;

public class UserService {
    private SqlSession sqlSession;

    public void registerUser() {
        sqlSession.insert("com.example.UserMapper.registerUser");
    }

    public void login() {
        sqlSession.selectOne("com.example.UserMapper.login");
    }
}

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <insert id="registerUser" parameterType="com.example.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
    <select id="login" parameterType="map" resultType="com.example.User">
        SELECT * FROM users WHERE name = #{username} AND password = #{password}
    </select>
</mapper>

// UserMapper.java
package com.example.mapper;

import com.example.User;

public interface UserMapper {
    void registerUser(User user);
    User login(Map<String, String> params);
}

// ProductMapper.xml
<mapper namespace="com.example.mapper.ProductMapper">
    <select id="getProductById" resultType="com.example.Product">
        SELECT * FROM products WHERE id = #{id}
    </select>
</mapper>

// ProductMapper.java
package com.example.mapper;

import com.example.Product;

public interface ProductMapper {
    Product getProductById(int id);
}

// ProductService.java
package com.example;

import com.example.mapper.ProductMapper;

public class ProductService {
    private ProductMapper productMapper;

    public Product getProductById(int id) {
        return productMapper.getProductById(id);
    }
}

// OrderService.java
package com.example;

import com.example.User;
import com.example.Product;

public class OrderService {
    public void placeOrder(User user, Product product) {
        // Place an order for the user and product
    }
}

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

// LoginAction.java
package com.example;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {
    private String username;
    private String password;
    private UserService userService;

    public String execute() {
        userService.login();
        if (userService.isLoggedIn()) {
            return "success";
        } else {
            return "error";
        }
    }

    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 UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

<!-- login.jsp -->
<form action="login">
    Username: <input type="text" name="username" />
    Password: <input type="password" name="password" />
    <input type="submit" value="Login" />
</form>

常见问题与解决方案

在使用Java框架进行开发时，经常会遇到一些常见的问题。下面是一些常见的问题及其解决方案。

问题1：Spring框架中的bean初始化问题

问题描述：在使用Spring框架时，可能会遇到bean初始化的问题。例如，某些bean在初始化时出现异常。

解决方案：在applicationContext.xml配置文件中，可以通过<bean>标签的init-method属性来指定bean的初始化方法。这样，在Spring容器初始化bean时，会自动调用指定的方法。

<bean id="userService" class="com.example.UserService" init-method="init" />

public void init() {
    // Initialization code
}

问题2：MyBatis框架中的SQL执行问题

问题描述：在使用MyBatis框架时，可能会遇到SQL执行的问题。例如，某些SQL语句执行失败。

解决方案：在UserMapper.xml配置文件中，可以通过<select>标签的resultType属性来指定SQL查询语句的返回类型。同时，还可以通过<if>标签来检查参数值是否满足条件，从而动态地生成不同的SQL语句。

<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
        <if test="name != null">
            AND name = #{name}
        </if>
    </select>
</mapper>

问题3：Hibernate框架中的缓存问题

问题描述：在使用Hibernate框架时，可能会遇到缓存的问题。例如，某些查询结果不一致。

解决方案：在hibernate.cfg.xml配置文件中，可以通过<property>标签的hibernate.cache.use_second_level_cache属性来启用二级缓存。同时，还可以通过<mapping>标签的<class>标签的<cache>标签来启用类级别的缓存。

<property name="hibernate.cache.use_second_level_cache">true</property>
<mapping class="com.example.User">
    <cache usage="read-write" />
</mapping>

问题4：Struts框架中的Action代理问题

问题描述：在使用Struts框架时，可能会遇到Action代理的问题。例如，某些Action处理未被正确代理。

解决方案：在struts.xml配置文件中，可以通过<action>标签的<interceptor-ref>标签来引用一个拦截器栈。通过拦截器栈，可以将Action处理的执行逻辑进行代理。

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

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

隔江千里

手记
篇

粉丝

39

获赞与收藏

182

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19244 315

Java 并发原理入门教程

26个小节 38983 568

Java 入门教程

50个小节 341700 3163

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空