欢迎加入
「易源易彩交流群」
「易源易彩交流群」
QQ扫码进群
（QQ群号：860213912）
注册得好礼
新用户微信注册享20元算力, >立即注册
关注公众号得算力
新用户关注易彩微信公众号享20元算力，
邀请有礼
邀请1人得5元算力，可累计叠加, 查看规则
本文介绍了 openFrame —— 一款基于 J2EE 技术的开源应用程序框架。该框架为开发者提供了灵活且高效的开发工具，旨在简化应用开发流程并提升开发效率。为了帮助读者更好地理解和应用 openFrame，本文提供了丰富的代码示例，覆盖了框架的不同功能和应用场景。
openFrame, J2EE技术, 开源框架, 代码示例, 应用开发
随着企业级应用需求的不断增长和技术的快速发展，传统的应用开发方式面临着诸多挑战，如开发周期长、维护成本高、难以适应快速变化的业务需求等。在此背景下，openFrame 应运而生，它是一款基于 J2EE 技术的开源应用程序框架，旨在解决上述问题，为开发者提供一套灵活、高效的开发工具。
openFrame 的出现极大地简化了应用开发流程，提升了开发效率。它不仅支持多种开发模式，还提供了丰富的组件和工具，使得开发者可以更加专注于业务逻辑的实现，而不是繁琐的基础架构搭建。此外，openFrame 还拥有活跃的社区支持，开发者可以轻松获取到最新的技术文档、教程和代码示例，这对于初学者来说尤其重要。
openFrame 采用了先进的 J2EE 技术栈，包括但不限于 Servlets、JSP、EJB 等，这些技术共同构成了 openFrame 的坚实基础。接下来，我们将从几个关键方面来解析 openFrame 的核心技术与架构特点。
通过以上介绍，我们可以看出 openFrame 不仅具备强大的技术实力，还拥有灵活的架构设计，这使得它成为了众多开发者心目中的理想选择。接下来的部分，我们将通过具体的代码示例来进一步探讨 openFrame 的应用实践。
在开始使用 openFrame 进行开发之前，首先需要确保开发环境已经正确配置。以下是安装 openFrame 所需的基本环境要求：
OPENFRAME_HOME。conf 目录下，编辑 server.xml 文件，配置数据源等必要参数。webapps 目录下。通过以上步骤，我们已经完成了 openFrame 的安装和配置工作。接下来的部分，我们将通过一系列具体的代码示例来深入了解 openFrame 的应用实践。
在 openFrame 框架中，控制器（Controller）扮演着至关重要的角色，它负责接收用户的请求，并调用相应的模型（Model）来处理这些请求。接下来，我们将通过一个具体的例子来说明如何在 openFrame 中实现控制器。
假设我们需要开发一个简单的在线购物系统，其中包含一个商品列表页面。当用户访问该页面时，控制器需要从数据库中获取商品信息，并将其传递给视图层进行显示。
// 导入必要的包
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class ProductListServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1. 调用模型层获取商品列表
List<Product> productList = ProductService.getInstance().getProductList();
// 2. 将商品列表存储到 request 对象中，以便在视图层使用
request.setAttribute("productList", productList);
// 3. 转发请求到 JSP 页面
RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/productList.jsp");
dispatcher.forward(request, response);
}
}
在这个示例中，我们定义了一个名为 ProductListServlet 的控制器类，它继承自 HttpServlet 类。在 doGet 方法中，我们首先调用了 ProductService 类的静态方法 getInstance().getProductList() 来获取商品列表。接着，我们将商品列表存储到了 request 对象中，并通过 RequestDispatcher 将请求转发到了名为 productList.jsp 的 JSP 页面。
ProductService 获取商品列表，实现了业务逻辑与控制器的解耦。setAttribute 方法将商品列表传递给视图层，便于后续的数据展示。RequestDispatcher 实现视图层的转发，保证了数据的一致性和安全性。模型层是 openFrame 框架的核心组成部分之一，它主要负责处理业务逻辑和数据操作。下面，我们将通过一个具体的例子来说明如何在 openFrame 中实现模型层。
继续以上述的在线购物系统为例，我们需要实现一个服务类 ProductService，用于处理商品相关的业务逻辑。
// 导入必要的包
import java.util.List;
public class ProductService {
private static ProductService instance = null;
private ProductService() {}
public static ProductService getInstance() {
if (instance == null) {
synchronized (ProductService.class) {
if (instance == null) {
instance = new ProductService();
}
}
}
return instance;
}
public List<Product> getProductList() {
// 1. 调用 DAO 层获取商品列表
List<Product> productList = ProductDAO.getInstance().getProductList();
// 2. 返回商品列表
return productList;
}
}
在这个示例中，我们定义了一个名为 ProductService 的模型类，它采用单例模式来确保在整个应用中只有一个实例。getProductList 方法负责从数据库中获取商品列表，并返回给控制器。
ProductService 的唯一性，提高了资源利用率。ProductDAO 获取商品列表，实现了数据访问与业务逻辑的分离。视图层是 openFrame 框架中负责展示数据的部分，通常使用 JSP 页面来实现。下面，我们将通过一个具体的例子来说明如何在 openFrame 中实现视图层。
继续以上述的在线购物系统为例，我们需要实现一个 JSP 页面 productList.jsp，用于展示商品列表。
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>商品列表</title>
</head>
<body>
<h1>商品列表</h1>
<table border="1">
<tr>
<th>ID</th>
<th>名称</th>
<th>价格</th>
</tr>
<% for (Product product : (List<Product>) request.getAttribute("productList")) { %>
<tr>
<td><%= product.getId() %></td>
<td><%= product.getName() %></td>
<td><%= product.getPrice() %></td>
</tr>
<% } %>
</table>
</body>
</html>
在这个示例中，我们定义了一个名为 productList.jsp 的 JSP 页面，用于展示商品列表。页面通过 <% %> 标签嵌入 Java 代码，从 request 对象中获取商品列表，并将其展示在表格中。
request.getAttribute("productList") 获取商品列表。<% %> 标签遍历商品列表，并将其展示在表格中。通过以上示例，我们可以看到 openFrame 框架在实现 MVC 设计模式方面的强大能力。控制器、模型层和视图层之间的紧密协作，不仅简化了开发流程，还提高了代码的可维护性和可扩展性。
在 openFrame 框架中，ORM（Object-Relational Mapping，对象关系映射）框架的集成是实现数据持久化的重要手段。ORM 技术可以将数据库表中的记录映射为对象，使得开发者能够以面向对象的方式来操作数据库。接下来，我们将详细介绍如何在 openFrame 中集成 ORM 框架，并通过一个具体的例子来说明其应用实践。
openFrame 支持多种 ORM 框架的集成，常见的有 Hibernate、MyBatis 等。这里我们以 Hibernate 为例进行说明。
pom.xml 文件中添加 Hibernate 的依赖。
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.32.Final</version>
</dependency>
src/main/resources 目录下创建 hibernate.cfg.xml 文件，配置数据库连接信息及其它参数。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydatabase</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">password</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping class="com.example.model.Product"/>
</session-factory>
</hibernate-configuration>
Product.java。
package com.example.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private double price;
// Getter and Setter methods
}
接下来，我们将通过一个具体的例子来说明如何使用 Hibernate 在 openFrame 中实现数据的增删改查操作。
// 导入必要的包
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class ProductDAO {
private static Session session = null;
public static void main(String[] args) {
// 创建 Hibernate 配置对象
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
// 创建 Session 对象
session = configuration.buildSessionFactory().openSession();
// 插入一条数据
insertProduct(new Product("Laptop", 5999.99));
// 查询所有数据
List<Product> productList = getAllProducts();
productList.forEach(System.out::println);
// 更新一条数据
updateProduct(1L, "New Laptop", 6999.99);
// 删除一条数据
deleteProduct(1L);
// 关闭 Session
session.close();
}
public static void insertProduct(Product product) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// 开始事务
transaction = session.beginTransaction();
// 保存对象
session.save(product);
// 提交事务
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public static List<Product> getAllProducts() {
return session.createQuery("FROM Product", Product.class).list();
}
public static void updateProduct(Long id, String name, double price) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// 开始事务
transaction = session.beginTransaction();
// 加载对象
Product product = session.get(Product.class, id);
// 更新属性
product.setName(name);
product.setPrice(price);
// 提交事务
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
public static void deleteProduct(Long id) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// 开始事务
transaction = session.beginTransaction();
// 加载对象
Product product = session.get(Product.class, id);
// 删除对象
session.delete(product);
// 提交事务
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
}
hibernate.cfg.xml 文件配置 Hibernate 的连接信息和其它参数。Product。insertProduct、getAllProducts、updateProduct 和 deleteProduct 方法实现了数据的增删改查操作。通过以上示例，我们可以看到在 openFrame 中集成 Hibernate 并实现数据持久化是非常简单和直观的。ORM 框架的引入不仅简化了数据库操作，还提高了代码的可读性和可维护性。
事务管理是企业级应用开发中不可或缺的一部分，它可以确保数据的一致性和完整性。在 openFrame 框架中，事务管理可以通过多种方式进行实现，包括编程式事务管理和声明式事务管理。接下来，我们将详细介绍这两种事务管理方式，并通过具体的代码示例来说明其应用实践。
编程式事务管理是指在代码中显式地管理事务的开始、提交和回滚。这种方式适用于需要对事务进行精细控制的场景。
// 导入必要的包
import org.hibernate.Session;
import org.hibernate.Transaction;
public class ProductDAO {
private static Session session = null;
public static void main(String[] args) {
// 创建 Hibernate 配置对象
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
// 创建 Session 对象
session = configuration.buildSessionFactory().openSession();
// 插入一条数据
insertProductWithTransaction(new Product("Laptop", 5999.99));
// 关闭 Session
session.close();
}
public static void insertProductWithTransaction(Product product) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
// 开始事务
transaction = session.beginTransaction();
// 保存对象
session.save(product);
// 模拟异常
int i = 1 / 0;
// 提交事务
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
}
}
}
beginTransaction() 方法开始事务。声明式事务管理是指通过配置文件或注解来管理事务，这种方式更加简洁，减少了代码量，提高了可维护性。
// 导入必要的包
import org.springframework.transaction.annotation.Transactional;
@Service
public class ProductService {
@Autowired
private ProductDAO productDAO;
@Transactional
public void createProduct(Product product) {
productDAO.insertProduct(product);
}
}
@Transactional 注解标记需要进行事务管理的方法。通过以上示例，我们可以看到在 openFrame 中实现事务管理是非常简单和直观的。无论是编程式事务管理还是声明式事务管理，都能够有效地确保数据的一致性和完整性。开发者可以根据实际需求选择合适的方式来进行事务管理。
在企业级应用开发中，安全始终是至关重要的考虑因素。openFrame 框架通过集成安全框架来加强应用的安全性，确保数据和用户信息的安全。本节将介绍如何在 openFrame 中集成 Shiro 这一流行的安全框架，并通过具体的代码示例来说明其配置和应用实践。
pom.xml 文件中添加 Shiro 的依赖。
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.7.1</version>
</dependency>
src/main/resources 目录下创建 shiro.ini 文件，配置登录认证、权限控制等信息。
[users]
admin = admin, admin
[roles]
admin = *
[urls]
/login.jsp = anon
/logout.jsp = logout
/admin/* = roles[admin]
/user/* = authc
/ = authc
public class MyShiroRealm extends AuthorizingRealm {
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// 用户认证逻辑
}
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
// 用户授权逻辑
}
}
// 导入必要的包
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.util.Factory;
public class SecurityManagerExample {
public static void main(String[] args) {
// 创建 Shiro 的安全管理器工厂
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
// 创建安全管理器
SecurityManager securityManager = factory.getInstance();
// 将安全管理器设置到 SecurityUtils 中
SecurityUtils.setSecurityManager(securityManager);
// 获取当前的 Subject
Subject currentUser = SecurityUtils.getSubject();
// 创建用户名/密码令牌
UsernamePasswordToken token = new UsernamePasswordToken("admin", "admin");
try {
// 登录
currentUser.login(token);
} catch (Exception e) {
System.out.println("登录失败：" + e.getMessage());
}
// 输出登录状态
System.out.println("Is Authenticated? " + currentUser.isAuthenticated());
// 注销
currentUser.logout();
}
}
IniSecurityManagerFactory 创建安全管理器，并加载配置文件。UsernamePasswordToken 对象，并通过 Subject 的 login 方法进行登录。isAuthenticated 方法检查用户是否已登录。logout 方法注销用户。通过以上示例，我们可以看到在 openFrame 中集成 Shiro 安全框架是非常简单和直观的。Shiro 的引入不仅增强了应用的安全性，还简化了认证和授权的实现过程。
缓存机制是提高应用性能的关键技术之一。在 openFrame 框架中，通过集成 Ehcache 这一高性能的缓存框架，可以有效地减少数据库访问次数，加快数据处理速度。接下来，我们将详细介绍如何在 openFrame 中集成 Ehcache，并通过具体的代码示例来说明其应用实践。
pom.xml 文件中添加 Ehcache 的依赖。
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.6</version>
</dependency>
src/main/resources 目录下创建 ehcache.xml 文件，配置缓存策略。
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<diskStore path="java.io.tmpdir"/>
<defaultCache maxElementsInMemory="10000"
eternal="false"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
memoryStoreEvictionPolicy="LRU"/>
<cache name="products"
maxElementsInMemory="1000"
eternal="false"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
memoryStoreEvictionPolicy="LRU"/>
</ehcache>
public class ProductDAO {
private static CacheManager cacheManager = CacheManager.create("classpath:ehcache.xml");
private static Cache cache = cacheManager.getCache("products");
public Product getProductById(Long id) {
Element element = cache.get(id);
if (element != null) {
return (Product) element.getObjectValue();
} else {
Product product = getProductFromDatabase(id);
cache.put(new Element(id, product));
return product;
}
}
private Product getProductFromDatabase(Long id) {
// 从数据库中获取产品信息
return null;
}
}
ehcache.xml 文件配置缓存策略。ProductDAO 类中使用 Ehcache API 实现缓存功能。get 方法从缓存中获取数据。put 方法将数据存储到缓存中。通过以上示例，我们可以看到在 openFrame 中集成 Ehcache 并实现缓存机制是非常简单和直观的。Ehcache 的引入不仅提高了应用性能，还降低了数据库的压力。
插件化设计是 openFrame 框架的一个重要特性，它允许开发者根据实际需求选择合适的插件，以增强应用的功能。本节将介绍如何在 openFrame 中开发插件，并通过具体的代码示例来说明其扩展性分析。
public interface Plugin {
void execute();
}
public class LoggingPlugin implements Plugin {
@Override
public void execute() {
System.out.println("Logging plugin executed.");
}
}
public class Application {
public static void main(String[] args) {
Plugin loggingPlugin = new LoggingPlugin();
registerPlugin(loggingPlugin);
}
private static void registerPlugin(Plugin plugin) {
plugin.execute();
}
}
Plugin。LoggingPlugin 类，实现了插件接口中的 execute 方法。Application 类中注册插件，并调用 execute 方法。通过以上示例，我们可以看到在 openFrame 中开发插件是非常简单和直观的。插件化设计不仅提高了应用的灵活性，还增强了应用的扩展性。开发者可以根据实际需求选择合适的插件，以满足不同的业务需求。
在 openFrame 框架的应用开发过程中，代码性能的优化是确保应用高效稳定运行的关键。通过对代码进行细致的分析和合理的优化，可以显著提升应用的响应速度和用户体验。本节将介绍一些常用的代码性能分析工具和优化策略，并通过具体的代码示例来说明其应用实践。
// 导入必要的包
import org.apache.commons.dbcp2.BasicDataSource;
public class ProductDAO {
private static BasicDataSource dataSource = null;
static {
dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUsername("root");
dataSource.setPassword("password");
dataSource.setInitialSize(5); // 设置初始连接数
dataSource.setMaxTotal(20); // 设置最大连接数
}
public Product getProductById(Long id) {
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
stmt = conn.prepareStatement("SELECT * FROM products WHERE id = ?");
stmt.setLong(1, id);
rs = stmt.executeQuery();
if (rs.next()) {
Product product = new Product();
product.setId(rs.getLong("id"));
product.setName(rs.getString("name"));
product.setPrice(rs.getDouble("price"));
return product;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeResources(conn, stmt, rs);
}
return null;
}
private void closeResources(Connection conn, Statement stmt, ResultSet rs) {
try {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
BasicDataSource 配置数据库连接池，减少了连接的创建和销毁开销。finally 块确保所有打开的资源都被正确关闭，避免资源泄露。通过以上示例，我们可以看到在 openFrame 中实现代码性能优化是非常简单和直观的。合理利用性能分析工具和优化策略，可以显著提高应用的性能和稳定性。
在 openFrame 框架的应用开发过程中，难免会遇到各种各样的问题。本节将介绍一些常见的问题及其调试和解决方法，并通过具体的代码示例来说明其应用实践。
null。try-with-resources 语句块自动关闭资源，或者在 finally 块中手动关闭资源。// 导入必要的包
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class ProductDAO {
private static BasicDataSource dataSource = null;
static {
dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUsername("root");
dataSource.setPassword("password");
dataSource.setInitialSize(5); // 设置初始连接数
dataSource.setMaxTotal(20); // 设置最大连接数
}
public Product getProductById(Long id) {
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
stmt = conn.prepareStatement("SELECT * FROM products WHERE id = ?");
stmt.setLong(1, id);
rs = stmt.executeQuery();
if (rs.next()) {
Product product = new Product();
product.setId(rs.getLong("id"));
product.setName(rs.getString("name"));
product.setPrice(rs.getDouble("price"));
return product;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeResources(conn, stmt, rs);
}
return null;
}
private void closeResources(Connection conn, Statement stmt, ResultSet rs) {
try {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
finally 块确保所有打开的资源都被正确关闭，避免资源泄露。SQLException 异常，确保在发生异常时能够及时处理。通过以上示例，我们可以看到在 openFrame 中调试和解决问题是非常简单和直观的。合理利用调试工具和解决方法，可以有效提高应用的稳定性和可靠性。
在实际项目中，openFrame 框架的应用可以帮助企业快速构建稳定、高效的应用系统。以一家电子商务公司为例，该公司需要开发一个全新的在线购物平台，以满足日益增长的业务需求。在这个项目中，openFrame 框架发挥了重要作用，具体体现在以下几个方面：
通过以上分析可以看出，openFrame 框架在实际项目中的应用不仅提高了开发效率，还确保了系统的稳定性和安全性。
在使用 openFrame 框架进行项目开发的过程中，合理的开发流程和良好的团队协作是确保项目成功的关键因素。以下是一些推荐的做法：
通过以上流程，开发团队可以高效地完成项目的开发工作，并确保最终产品的质量和稳定性。
在项目完成后，部署和运维工作同样重要。以下是关于项目部署与运维的一些关键点：
通过以上措施，可以确保项目的稳定运行，并为用户提供优质的体验。
本文全面介绍了 openFrame —— 一款基于 J2EE 技术的开源应用程序框架。从框架的概述、安装配置、核心组件解析，到数据访问与事务管理、高级功能的应用，再到性能优化与调试，最后是实际项目案例分析、开发流程与团队协作以及项目部署与运维，本文提供了丰富的代码示例和实用的指导建议。
通过本文的学习，读者不仅可以了解到 openFrame 的强大功能和灵活架构，还能掌握如何在实际项目中应用这一框架，以提高开发效率和应用性能。openFrame 的模块化设计、代码重用机制、性能优化策略以及安全性保障等特点，使其成为企业级应用开发的理想选择。希望本文能够帮助开发者更好地理解和应用 openFrame，为构建高质量的应用系统打下坚实的基础。