1. 应用类型选择
– Web应用（WAR）：纯Web应用
– 企业应用（EAR）：需要EJB的应用
– 微服务：独立部署的服务

2. 技术栈选择
– Web层：Servlet/JSP/JSF
– 业务层：EJB/CDI
– 数据层：JPA/JDBC
– 消息层：JMS

3. 资源需求
– 数据源：数据库连接
– JMS资源：队列/主题
– 邮件资源：邮件会话
– URL资源：外部服务

4. 安全需求
– 认证方式
– 授权策略
– 数据加密

# 应用规划模板

应用名称：fgedu电商系统
应用类型：EAR
技术栈：
– Web层：JSF 2.2 + PrimeFaces
– 业务层：EJB 3.2 + CDI 1.1
– 数据层：JPA 2.1
– 消息层：JMS 2.0

资源需求：
– 数据源：jdbc/fgedudb
– JMS队列：jms/fgeduQueue
– 邮件会话：mail/fgeduMail

安全需求：
– 认证：LDAP
– 授权：基于角色

1. 分层架构
┌─────────────────────────────────────────────────────────┐
│ 表现层（Web） │
│ Servlet / JSF / JAX-RS │
└─────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────┐
│ 业务层（Service） │
│ EJB / CDI Bean │
└─────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────┐
│ 数据访问层（DAO） │
│ JPA / JDBC │
└─────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────┐
│ 数据层 │
│ 数据库 / 消息队列 │
└─────────────────────────────────────────────────────────┘

2. 模块划分
fgeduapp.ear
├── fgedu-web.war # Web模块
│ ├── 表现层组件
│ └── 静态资源
├── fgedu-ejb.jar # EJB模块
│ ├── 业务层组件
│ └── 数据访问组件
└── fgedu-common.jar # 公共模块
├── 工具类
└── 常量定义

3. 依赖管理
– 使用Maven/Gradle管理依赖
– 避免依赖冲突
– 合理使用共享库

# 架构设计原则

1. 关注点分离
– 表现层只处理展示
– 业务层只处理业务逻辑
– 数据层只处理数据访问

2. 松耦合
– 使用接口定义契约
– 依赖注入解耦组件
– 面向接口编程

3. 高内聚
– 相关功能放在同一模块
– 单一职责原则
– 模块边界清晰

1. 数据源配置
资源名称：jdbc/fgedudb
JNDI名称：jdbc/fgedudb
类型：javax.sql.DataSource
连接池：最小10，最大50

2. JMS资源配置
队列连接工厂：jms/fgeduQCF
队列：jms/fgeduQueue
主题：jms/fgeduTopic

3. 邮件资源配置
邮件会话：mail/fgeduMail
SMTP服务器：smtp.fgedu.net.cn
端口：25/465/587

4. URL资源配置
URL资源：url/fgeduApi
目标URL：http://api.fgedu.net.cn

# 资源引用配置

web.xml资源引用：

jdbc/fgedudb
javax.sql.DataSource
Container

jms/fgeduQCF
javax.jms.QueueConnectionFactory
Container

ejb-jar.xml资源引用：


FGeduService

jdbc/fgedudb
javax.sql.DataSource

com.fgedu.service.FGeduService
dataSource

# 注解方式资源注入

@Stateless
public class FGeduService {
@Resource(lookup = “jdbc/fgedudb”)
private DataSource dataSource;

@Resource(lookup = “jms/fgeduQCF”)
private QueueConnectionFactory qcf;

@Resource(lookup = “jms/fgeduQueue”)
private Queue queue;
}

1. 认证配置
方式：FORM认证
登录页面：/login.jsp
错误页面：/error.jsp

web.xml：

FORM
/login.jsp /error.jsp

2. 授权配置
角色：fgeduAdmin, fgeduUser, fgeduGuest

web.xml：

fgeduAdmin


fgeduUser

Admin
/admin/*


fgeduAdmin

3. EJB安全配置
@Stateless
@DeclareRoles({“fgeduAdmin”, “fgeduUser”})
public class FGeduService {

@RolesAllowed(“fgeduAdmin”)
public void adminOperation() {
// 管理员操作
}

@RolesAllowed({“fgeduAdmin”, “fgeduUser”})
public void userOperation() {
// 用户操作
}

@PermitAll
public void publicOperation() {
// 公开操作
}
}

# 安全角色映射

WebSphere管理控制台：
应用程序 > 应用程序类型 > WebSphere企业应用程序
> fgeduapp > 安全角色到用户/组映射

角色映射：
fgeduAdmin -> cn=fgeduadmins,ou=groups,dc=fgedu,dc=net,dc=cn
fgeduUser -> cn=fgeduusers,ou=groups,dc=fgedu,dc=net,dc=cn

1. 创建EJB模块
# Maven项目结构
fgedu-ejb/
├── src/main/java/
│ └── com/fgedu/
│ ├── service/
│ │ ├── FGeduService.java
│ │ └── FGeduServiceBean.java
│ └── entity/
│ └── FGeduUser.java
├── src/main/resources/
│ └── META-INF/
│ └── persistence.xml
└── pom.xml

2. EJB接口定义
public interface FGeduService {
FGeduUser findById(Long id);
List findAll();
void save(FGeduUser user);
void delete(FGeduUser user);
}

3. EJB实现类
@Stateless
@Local(FGeduService.class)
public class FGeduServiceBean implements FGeduService {

@PersistenceContext(unitName = “fgeduPU”)
private EntityManager em;

@Override
public FGeduUser findById(Long id) {
return em.find(FGeduUser.class, id);
}

@Override
public List findAll() {
return em.createQuery(“SELECT u FROM FGeduUser u”, FGeduUser.class)
.getResultList();
}

@Override
public void save(FGeduUser user) {
if (user.getId() == null) {
em.persist(user);
} else {
em.merge(user);
}
}

@Override
public void delete(FGeduUser user) {
em.remove(em.contains(user) ? user : em.merge(user));
}
}

4. 部署EJB模块
# 打包EJB JAR
mvn clean package

# 部署到WebSphere
/WebSphere/app/profiles/Dmgr01/bin/wsadmin.sh -lang jython \
-username fgeduadmin -password fgedu123

AdminApp.install(‘/WebSphere/apps/fgedu-ejb.jar’, ‘[-appname fgeduEjb]’)
AdminConfig.save()

# 验证部署
AdminApp.list()

fgeduEjb

5. EJB调用
# 在Web模块中调用EJB
@WebServlet(“/users”)
public class UserServlet extends HttpServlet {

@EJB
private FGeduService fgeduService;

protected void doGet(HttpServletRequest request,
HttpServletResponse response) {
List users = fgeduService.findAll();
request.setAttribute(“users”, users);
request.getRequestDispatcher(“/users.jsp”).forward(request, response);
}
}

1. JPA实体定义
@Entity
@Table(name = “FGEDU_USER”)
@NamedQuery(name = “FGeduUser.findByUsername”,
query = “SELECT u FROM FGeduUser u WHERE u.username = :username”)
public class FGeduUser {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = “ID”)
private Long id;

@Column(name = “USERNAME”, nullable = false, unique = true, length = 50)
private String username;

@Column(name = “PASSWORD”, nullable = false, length = 100)
private String password;

@Column(name = “EMAIL”, length = 100)
private String email;

@Temporal(TemporalType.TIMESTAMP)
@Column(name = “CREATE_TIME”)
private Date createTime;

@OneToMany(mappedBy = “user”, cascade = CascadeType.ALL)
private List orders;

// getters and setters
}

2. JPA配置文件
persistence.xml：
jdbc/fgedudb
com.fgedu.entity.FGeduUser
com.fgedu.entity.FGeduOrder

3. JPA使用示例
@Stateless
public class FGeduUserService {

@PersistenceContext(unitName = “fgeduPU”)
private EntityManager em;

// 保存用户
public FGeduUser createUser(FGeduUser user) {
user.setCreateTime(new Date());
em.persist(user);
return user;
}

// 更新用户
public FGeduUser updateUser(FGeduUser user) {
return em.merge(user);
}

// 删除用户
public void deleteUser(Long id) {
FGeduUser user = em.find(FGeduUser.class, id);
if (user != null) {
em.remove(user);
}
}

// 查询用户
public FGeduUser findById(Long id) {
return em.find(FGeduUser.class, id);
}

// 按用户名查询
public FGeduUser findByUsername(String username) {
TypedQuery query = em.createNamedQuery(
“FGeduUser.findByUsername”, FGeduUser.class);
query.setParameter(“username”, username);
try {
return query.getSingleResult();
} catch (NoResultException e) {
return null;
}
}

// 分页查询
public List findAll(int page, int size) {
TypedQuery query = em.createQuery(
“SELECT u FROM FGeduUser u ORDER BY u.createTime DESC”,
FGeduUser.class);
query.setFirstResult((page – 1) * size);
query.setMaxResults(size);
return query.getResultList();
}

// 统计数量
public long count() {
Query query = em.createQuery(“SELECT COUNT(u) FROM FGeduUser u”);
return (Long) query.getSingleResult();
}
}

4. JPA Criteria查询
public List searchUsers(String username, String email) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery cq = cb.createQuery(FGeduUser.class);
Root user = cq.from(FGeduUser.class);

List predicates = new ArrayList<>();

if (username != null && !username.isEmpty()) {
predicates.add(cb.like(user.get(“username”), “%” + username + “%”));
}

if (email != null && !email.isEmpty()) {
predicates.add(cb.like(user.get(“email”), “%” + email + “%”));
}

cq.where(predicates.toArray(new Predicate[0]));

return em.createQuery(cq).getResultList();
}

1. 创建JMS资源
# 通过管理控制台
资源 > JMS > 队列连接工厂
资源 > JMS > 队列

# 通过wsadmin创建
/WebSphere/app/profiles/Dmgr01/bin/wsadmin.sh -lang jython \
-username fgeduadmin -password fgedu123

# 创建队列连接工厂
AdminJMS.createWASQueueConnectionFactory(‘[-name fgeduQCF -jndiName jms/fgeduQCF -scope Node]’)

# 创建队列
AdminJMS.createWASQueue(‘[-name fgeduQueue -jndiName jms/fgeduQueue -scope Node]’)

AdminConfig.save()

2. JMS消息发送
@Stateless
public class FGeduMessageService {

@Resource(lookup = “jms/fgeduQCF”)
private QueueConnectionFactory qcf;

@Resource(lookup = “jms/fgeduQueue”)
private Queue queue;

public void sendMessage(String message) {
Connection connection = null;
Session session = null;
MessageProducer producer = null;

try {
connection = qcf.createConnection();
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
producer = session.createProducer(queue);

TextMessage textMessage = session.createTextMessage(message);
producer.send(textMessage);

System.out.println(“消息发送成功: ” + message);

} catch (JMSException e) {
throw new RuntimeException(“消息发送失败”, e);
} finally {
try {
if (producer != null) producer.close();
if (session != null) session.close();
if (connection != null) connection.close();
} catch (JMSException e) {
// ignore
}
}
}
}

3. JMS消息接收（消息驱动Bean）
@MessageDriven(
activationConfig = {
@ActivationConfigProperty(propertyName = “destinationType”,
propertyValue = “javax.jms.Queue”),
@ActivationConfigProperty(propertyName = “destination”,
propertyValue = “jms/fgeduQueue”)
}
)
public class FGeduMessageListener implements MessageListener {

@Override
public void onMessage(Message message) {
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
String text = textMessage.getText();
System.out.println(“收到消息: ” + text);

// 处理消息
processMessage(text);
}
} catch (JMSException e) {
e.printStackTrace();
}
}

private void processMessage(String message) {
// 业务处理逻辑
}
}

4. JMS事务配置
@Stateless
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public class FGeduOrderService {

@Resource(lookup = “jms/fgeduQCF”)
private QueueConnectionFactory qcf;

@Resource(lookup = “jms/fgeduQueue”)
private Queue queue;

@PersistenceContext
private EntityManager em;

public void createOrder(FGeduOrder order) {
// 保存订单到数据库
em.persist(order);

// 发送消息通知
sendMessage(“订单创建: ” + order.getId());

// 如果任何一步失败，整个事务回滚
}

private void sendMessage(String message) {
// JMS消息发送
}
}

1. 事务属性配置
@Stateless
public class FGeduTransactionService {

// 默认：REQUIRED
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void requiredMethod() {
// 如果存在事务则加入，否则创建新事务
}

// 需要新事务
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public void requiresNewMethod() {
// 总是创建新事务，挂起当前事务
}

// 强制要求事务
@TransactionAttribute(TransactionAttributeType.MANDATORY)
public void mandatoryMethod() {
// 必须在事务中调用，否则抛出异常
}

// 不支持事务
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public void notSupportedMethod() {
// 挂起当前事务，以非事务方式执行
}

// 支持事务
@TransactionAttribute(TransactionAttributeType.SUPPORTS)
public void supportsMethod() {
// 如果存在事务则加入，否则以非事务方式执行
}

// 从不使用事务
@TransactionAttribute(TransactionAttributeType.NEVER)
public void neverMethod() {
// 必须在非事务中调用，否则抛出异常
}
}

2. 分布式事务示例
@Stateless
public class FGeduDistributedService {

@PersistenceContext(unitName = “fgeduPU”)
private EntityManager em1;

@PersistenceContext(unitName = “fgeduPU2”)
private EntityManager em2;

@Resource(lookup = “jms/fgeduQCF”)
private QueueConnectionFactory qcf;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void distributedOperation() {
// 操作数据库1
FGeduUser user = new FGeduUser();
user.setUsername(“fgedu”);
em1.persist(user);

// 操作数据库2
FGeduLog log = new FGeduLog();
log.setMessage(“用户创建”);
em2.persist(log);

// 发送JMS消息
// sendMessage(“操作完成”);

// 所有操作在同一事务中
// 任何失败都会回滚所有操作
}
}

3. 事务超时配置
@Stateless
@TransactionTimeout(300) // 5分钟超时
public class FGeduLongRunningService {

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void longRunningOperation() {
// 长时间运行的事务
}
}

4. 事务回滚控制
@Stateless
public class FGeduRollbackService {

@Resource
private SessionContext sessionContext;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void rollbackExample() {
try {
// 业务操作
doSomething();
} catch (Exception e) {
// 标记事务回滚
sessionContext.setRollbackOnly();
throw e;
}
}

private void doSomething() {
// 业务逻辑
}
}

# WebSphere事务配置

管理控制台：
服务器 > server1 > 容器服务 > 事务服务

配置项：
– 总事务超时：120秒
– 客户端事务超时：300秒
– 最大事务数：10000
– 启用Heuristic处理：是