原有功能

会员

• 会员注册
• 会员资格激活／取消
• 预定／取消预订
• 修改卡信息
• 查看本人统计信息

客栈

• 开店申请／修改信息
• 发布计划
• 入住／离店登记
• 查看本店统计信息

规划项目层次&功能

维度分析

根据现有业务数据，对新管理系统的分析维度进行划分：

时间维度

• 日期关键字
• 日历年月日（YYYY-MM-DD）
• 星期
• 月份
• 季度
• 年
• 节假日指示符

地点维度

• 地点关键字
• 地点
• 省份

订单维度

• 订单关键字
• 订单自然关键字
• 下单时间
• 房间类型
• 下单数量
• 入住时间
• 订单总额
• 支付方式
• 订单状态

客户维度

• 客户关键字
• 客户自然关键字
• 客户昵称
• 客户真实姓名
• 客户生日
• 客户年龄
• 客户等级
• 客户积分

房间维度

• 房间关键字
• 房间自然关键字
• 房间所属客栈ID
• 房间名称
• 房间价格
• 房间上架时间
• 所在城市
• 详细地址
• 房间详细信息

业务处理／度量值&指标

在某时间地点的各类型房间收益

选取维度：时间维度、房间维度、地点维度
选取事实表：订单事实表
选取度量值：订单金额
管理分析：各时间地点各类型房间收益，ADR (Average Daily Rate)——已售客房平均房价，方便调整房间价格和优惠方案

入住率

选取维度：时间维度、房间维度、地点维度
选取事实表：入住事实表
选取度量值：入住房间数、总房间数
管理分析：各时间地点各类型房间入住比率，方便调整房间策略和优惠方案

有效订单数量

选取维度：时间维度、房间维度
选取事实表：订单事实表
选取度量值：订单是否成交 -> 订单成交率
管理分析：了解订单真正转化为收入的比率，方便调整房间策略和优惠方案

RFM模型分析和客户细分

选取维度：时间维度、客户维度、房间维度
选取事实表：订单事实表
选取度量值：入住时间、订单数量、订单金额
管理分析：
根据用户最近一次消费(Recency)、消费频率(Frequency)、消费金额(Monetary)将用户划分为八类用户，选取重要客户：

• 重要价值客户（111）：最近消费时间近、消费频次和消费金额都很高，VIP
• 重要保持客户（011）：最近消费时间较远，但消费频次和金额都很高，说明这是个一段时间没来的忠实客户，我们需要主动和他保持联系
• 重要发展客户（101）：最近消费时间较近、消费金额高，但频次不高，忠诚度不高，很有潜力的用户，必须重点发展
• 重要挽留客户（001）：最近消费时间较远、消费频次不高，但消费金额高的用户，可能是将要流失或者已经要流失的用户，应当基于挽留措施

作为一个抢劫犯，你需要入侵一条街上的房子。房子中的财产以给定的数组表示。不能入侵相邻的两座房子，否则会引发警报。计算可以获取的财产总额的最大值。

算法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Solution {
    public int rob(int[] nums) {
        int preNo = 0;	//偷了之前的房子
        int preYes = 0; //没偷之前的房子
        for(int i=0;i<nums.length;i++) {
            int value = nums[i];
            int tmp = preNo + value;    //rob
            //比较之前没偷和之前偷了的两种结果，决定当前不偷的最大金额
            preNo = preNo > preYes ? preNo : preYes;
            preYes = tmp;
        }
        return preNo > preYes ? preNo : preYes;
    }
}

给出匹配字符串，使用”*“代表任意字符序列，使用”?”代表任意一个字符。给出目标字符串，判断是否匹配。
Some examples:
isMatch(“aa”,”a”) → false
isMatch(“aa”,”aa”) → true
isMatch(“aaa”,”aa”) → false
isMatch(“aa”, “*“) → true
isMatch(“aa”, “a*“) → true
isMatch(“ab”, “?*“) → true
isMatch(“aab”, “c*a*b”) → false

算法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class Solution {
    public boolean isMatch(String str, String pattern) {
        int s = 0, p = 0, match = 0, starIdx = -1;            
        while (s < str.length()){
            // advancing both pointers
            if (p < pattern.length()  && (pattern.charAt(p) == '?' || str.charAt(s) == pattern.charAt(p))){
                s++;
                p++;
            }
            // * found, only advancing pattern pointer
            else if (p < pattern.length() && pattern.charAt(p) == '*'){
                starIdx = p;
                match = s;
                p++;
            }
           // last pattern pointer was *, advancing string pointer
           // 此处一直匹配到最后一处可能一致的地方，选取的是最大范围的"*"，是贪婪的
            else if (starIdx != -1){
                p = starIdx + 1;
                match++;
                s = match;
            }
           //current pattern pointer is not star, last patter pointer was not *
          //characters do not match
            else return false;
        }
        
        //check for remaining characters in pattern
        while (p < pattern.length() && pattern.charAt(p) == '*')
            p++;
        
        return p == pattern.length(); 
    }
}

给出非负的整数数组a1…an，和一个目标数target。对数组中的每一个数，都可以选择+或者-。找出有多少种+／-的组合方法可以得到目标数target。

考虑到sum(P) - sum(N) = target（sum(P)是符号为正的数的和，sum(N)是符号为负的数的和），可以得出sum(P) = sum(N) + target，即2 * sum(P) = target + sum(N) + sum(p) = target + sum。将问题转化为求符号为正的数的和为target + sum的组合的个数。

算法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Solution {
    public int findTargetSumWays(int[] nums, int s) {
        int sum = 0;
        for (int n : nums)
            sum += n;
        return sum < s || (s + sum) % 2 > 0 ? 0 : subsetSum(nums, (s + sum) >>> 1); 
    }   
	/**
	 * 这个函数是采用迭代的方式计算数组中和为s的个数
	 */
    public int subsetSum(int[] nums, int s) {
        int[] dp = new int[s + 1]; 
        dp[0] = 1;
        for (int n : nums)
            for (int i = s; i >= n; i--)
                dp[i] += dp[i - n]; 
        return dp[s];
    }
}

给定一个由”0””1”组成的字符串列表(如{“0”, “110”, “1001”})。找出可以由m个0和n个1组成的最大字符串个数。

算法采用一个m+1行和n+1列的数组保存每次迭代后的对应numOfZero个0，numOfOne个1组成的个数加一:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] matrix = new int[m + 1][n + 1];
        int numOfZero = 0;
        int numOfOne = 0;
        for (int i=0;i<strs.length;i++) {
            numOfZero = numOfOne = 0;
            String s = strs[i];
            for (int j=0;j<s.length();j++) {
                if (s.charAt(j) == '0') {
                    numOfZero++;
                } else {
                    numOfOne++;
                }
            }
            for (int x=m;x>=numOfZero;x--) {
                for (int y=n;y>=numOfOne;y--) {
                    matrix[x][y] = Math.max(matrix[x][y], matrix[x-numOfZero][y-numOfOne] + 1);
                }
            }
        }
        return matrix[m][n];
    }
}

完全复制一个具有随机指针（指向任意一个节点或者为null）的链表。

实现方法很多，这里给出一个空间复杂度O(1)，时间复杂度O(n)的算法。它利用原来的链表对新建链表的随机指针进行定位。

算法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/**
 * Definition for singly-linked list with a random pointer.
 * class RandomListNode {
 *     int label;
 *     RandomListNode next, random;
 *     RandomListNode(int x) { this.label = x; }
 * };
 */
public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null) {
            return null;
        }
        
        RandomListNode itr = head;
        RandomListNode next;
        
        /**
         * 该循环将复制的节点连接到被复制的节点后面，形成
         * 原节点1 -> 复制节点1 -> 原节点2 -> 复制节点2的情况，
         * 保留了位置信息
         */
        while (itr != null) {
            next = itr.next;
            
            RandomListNode copy = new RandomListNode(itr.label);
            itr.next = copy;
            copy.next = next;
            
            itr = next;
        }
        
        //此处循环根据原节点可以很方便的把复制节点的random指针找到
        itr = head;
        while (itr != null) {
            if (itr.random != null) {
                itr.next.random = itr.random.next;
            } else {
                itr.next.random = null;
            }
            
            itr = itr.next.next;
        }
        
        //将原链表还原，新链表重新连接
        RandomListNode copyHead = new RandomListNode(0);
        RandomListNode itrCopy = copyHead;
        itr = head;
        while (itr != null) {
            itrCopy.next = itr.next;
            itrCopy = itrCopy.next;
            itr.next = itrCopy.next;
            itr = itr.next;
        }
        
        return copyHead.next;
    }
}

给定一个二叉树，找到图中具有最大和的路径。路径必须有至少一个node，从任意节点开始，任意节点结束，不需要经过root节点。节点值可以为负数。

算法如下(参考https://discuss.leetcode.com/topic/4407/accepted-short-solution-in-java):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
	//该算法主要通过对比maxValue变量来记录最大路径长度
    int maxValue;	
    
    public int maxPathSum(TreeNode root) {
        maxValue = Integer.MIN_VALUE;
        maxPathGoingDown(root);
        return maxValue;
    }
    
    public int maxPathGoingDown(TreeNode node) {
        if (node == null) return 0;
        
        //对节点值为负数作出考虑，即当左右子女值均为负数的时候，则路径不向左右节点延伸
        int left = Math.max(0, maxPathGoingDown(node.left));
        int right = Math.max(0, maxPathGoingDown(node.right));
        
        //对当前最大路径和左右子女根到叶节点最大路径（也有可能在中途停止）与当前节点值的和比较
        maxValue = Math.max(maxValue, left + right + node.val);
        
        //返回值是当前节点作为根到叶节点的最大路径（可能中途停止）
        return Math.max(left, right) + node.val;
    }
}

什么是软件架构

SEL: 软件架构是整个程序或计算系统的结构，包含了程序的元素和外部可见的元素属性，以及它们之间的关系。

软件架构做什么

• 架构定义了结构：组件接口、组件的交流和依赖、组件的职责
• 架构定义了组件的交流：数据传输机制、控制流
• 架构传达了NFRs：技术约束、商业约束、质量约束
• 架构是设计的高层抽象视图

PS:

• 联系
• 软件工程
• 技术知识
• 风险管理

软件架构如何而来

• 需求
• 商业和技术决定的集合
• 受以下因素影响：
  • 系统利益相关址
  • 开发组织
  • 架构师
  • 系统环境

架构的视图

• 逻辑视图：定义了必要的元素和关系
• 进程视图：描述了元素间的交流、依赖
• 物理视图：进程和元素到硬件的映射
• 开发视图：捕捉软件内部组件的组织
• 架构用例：描述了架构的需求

架构活动过程

• 活动
  • 为软件创造商业用例
  • 理解需求
  • 设计选择架构
  • 与利益相关者交流架构
  • 分析评估架构
  • 实现架构
  • 保证一致性
• 四大步骤
  • 发现ASRs
  • 架构设计
  • 完成视图和文档
  • 架构评估
• 生命周期
  • 架构设计
  • 架构合成
  • 架构评估
  • 架构实现
  • 架构维护

架构知识领域

• 软件设计基础概念
  • 设计概念常识
  • 上下文：软件开发生命周期：需求、设计、构造\测试
  • 设计过程
  • 在设计中使用技术
• 关键点
  • 并发、控制和处理时间，分布式，异常处理，交互系统，持久化
• 软件的结构和架构
  • 架构的结构和观点
  • 架构的模式和风格
  • 设计模式
• 软件设计方法
  • 架构方法：ADD
  • 设计方法：DSDM
• 软件设计质量分析和评估
  • ATAM
• 设计模块化和展示
  • UML

为何架构十分重要

• 提供交流的途径
• 显示最早的设计决策
• 促进质量属性的实现
• 影响质量
• 讨论潜在变化
• 将变化分为三类：local, non-local, architectural
• 是透明和可复用的抽象
• 是产品通用的基础

选件要求

• 功能需求
  • 功能需求描述了如何给利益相关者产生价值
  • 功能需求描述了系统的职责
• 质量需求
  • 质量需求用于检验功能需求以及整个系统的质量
• 约束
  • 约束描述了设计中零自由度的决策

场景

• stimulus
• source
• response
• response measure
• artifact
• environment

质量属性设计决策的7大分类

• Allocation of responsibilities
• Coordination model
• Data model
• Management of resources
• Mapping among architectural elements
• Binding time decisions
• Choice of technology

质量属性

• Availability
  • 发现错误的时间
  • 修正错误的时间
  • 重启应用的时间
• Interoperability
  • 系统之间通过接口交换信息的属性，包括交换和正确理解信息
• Modifiability
  • 评估一个更改要消耗的时间和金钱
• Performance
  • 关于系统满足时间要求的能力
  • 处理时间和阻塞时间
• Security
  • 关于系统保证信息和数据安全的能力
• Testability
  • 关于系统能否通过测试证明出错的能力
• Usability
  • 用户完成某一项任务的容易性

Availability Tactics

• 发现错误
• 从错误恢复
• 防止错误

Interoperability Tactics

• 服务定位
• 服务管理

Modifiability Tactics

• 减少模块大小
• 提高内聚
• 减少耦合
• 延迟绑定

Performance Tactics

• 控制资源需求
• 资源管理

Security Tactics

• 攻击检测
• 攻击抵抗
• 攻击反应
• 攻击恢复

Testability Tactics

• 控制和观察系统状态
• 限制复杂度

Usability Tactics

• 支持用户自发操作：暂停
• 支持系统自发操作：维护任务模式

如何获取ASRs

• 从需求文档中获取
• 从利益相关人员获取
• 理解商业目标
• 从质量属性效用树中获取

特定域软件体系结构DSSA

什么是架构模式pattern

• 是在不断尝试中找到的一种设计的集合
• 可复用
• 一种架构的类别
• 包括：上下文、问题和解决方案

Model patterns

• 分层模式
  • 上下文：层，只能访问下层
  • 优点：
    • 逻辑分离
    • 限制数据暴露
  • 缺点：
    • 添加层会增加成本和系统复杂度
    • 影响性能

Component-Connector patterns

• 代理模式
  • 上下文：服务器、客户端、中间人、服务器代理、客户端代理，客户端和服务器通过代理提供接口，通过中间人交流
  • 优点：
    • 服务位置透明
  • 缺点：
    • 提高复杂度
    • 导致单点失效
    • 成为攻击对象
    • 难以测试
• MVC模式
  • 上下文：model、view、controller
  • 优点：
    • 视图层修改方便
  • 缺点：
    • 复杂度高不适用于简单界面
    • 不支持一些高级界面工具
• 管道过滤模式
  • 上下文：管道、过滤器，管道的输出是过滤器的输入，反之亦然
  • 优点：
    • 将复杂任务分开，方便部署计算密集型任务
    • 复杂任务分解，提高复用
  • 缺点：
    • 不适合内部交互系统
    • 大量独立的过滤器导致大量计算开销
    • 不适合长时间计算
• 客户端服务器模式
  • 上下文：客户端、服务器，客户端连接服务器
  • 优点：
    • 满足个性化要求
  • 缺点：
    • 服务器可能成为瓶颈
    • 服务器可能单点失效
    • 功能放置在客户端还是服务器的决策复杂并且难以修改
• 点对点模式
  • 上下文：peer，独立运行，通过request／reply连接其他peer
  • 优点：
    • 资源分散，无需中间环节，避免性能瓶颈
  • 缺点；
    • 管理安全、数据持久化、数据／服务可用性、备份和恢复的复杂度提高
    • 小型对等网络难以一直保持性能和可用性
• 面向服务模式
  • 上下文：
    • 组件：服务提供者、服务消费者、服务、ESB、注册中心
    • 连接件：SOAP、REST、异步信息连接
  • 优点：
    • 从已有的服务上建立商业过程，组件复用和解耦
  • 缺点：
    • 复杂难以实现
    • 难以控制独立服务的演化
    • 服务和中间件成为性能的瓶颈
• 发布订阅模式
  • 上下文：任何C&C组件都有发布订阅模式，订阅消息的组件会收到发布消息的组件的信息
  • 优点：
    • 降低耦合
  • 缺点：
    • 提高延迟，降低可量测性，难以预测信息的分发时间
    • 分发信息不能保证
• 共享数据模式
  • 上下文：共享数据存储、数据访问组件、数据读写连接件
  • 优点：

    * 提供统一接口方便操作
    

    • 缺点：
      • 共享数据存储模块成为性能瓶颈
      • 共享数据存储模块单点失效
      • 生产者和消费者的耦合

Allocation patterns

• 多链模式
  • 上下文：tier，软件组件的逻辑分组，is part of将组件分入tier，communicate with是tier之间的交流，allocate to是tier映射到计算平台
  • 优点：
    • 分离组件到层，部署在不同的物理平台
  • 缺点：
    • 大量的开销和复杂度

• 映射归纳模式
  • 上下文：map、reduce
  • 优点：
    • 为并行计算提供框架，提高运行速度
  • 缺点：
    • 如果数据集合不够大，将没有理由使用
    • 如果不能将数据集合划分为大小相近的集合，将丧失并行计算的优势
    • 需要多重归纳的操作将难以安排

模式和策略Patterns and Tactics

• tactics更简单，密度更小
• patterns包含不同的设计决策
• patterns和tactics共同构建了整个架构基础的工具
• tactics是patterns设计的架构的基础材料
• patterns里的tactics可能是为了一个目的，也可能是不同的目的

设计策略Design Strategy

• abstraction
• decomposition
• divide & conquer
• generation and test
• iteration
• reuse

ADD

• 确认需求
• 选择一个元素进行分解
• 为该元素确认ASRs
  • importance, difficulty
• 选择符合ASRs的设计理念
  • 确认设计关注点
  • 为次要关注度列出不同的模式／策略
  • 选择合适的模式／策略
  • 决定ASRs和模式／策略之间的关系
  • 获取架构视图
  • 评估并解决不一致问题
• 列出架构元素，分配职责
• 为元素定义接口
• 确认需求，为元素构造约束
• 重复以上步骤

ADD的输入

• 功能需求
• 设计约束
• 质量属性

ADD的输出

• 软件元素
• 角色
• 职责
• 特性
• 关系

为什么要文档化

• 更好的交流架构设计决定
• 帮助理解决策
• 更新设计者关于当前决定的记忆
• 锻炼设计架构的能力
• 支持分布式团队

文档化的挑战

• 没有标准化
• 大型系统花费时间长
• 逼近deadline和架构不断变化的性质对文档化有害
• 注释缺失

文档化的七条原则

• 以读者的视角完成文档
• 避免不必要的重复
• 避免歧义
• 使用标准组织
• 记录理由
• 保持文档接近最新
• 审查文档保证契合目的

Styles的分类

• Module style
• C&C style
• Allocation style

Style/Pattern/View

• Style: 元素和关系类型的特化，以及如何使用的约束
  • 不包含上下文和问题
• Pattern: 软件的基本结构组织模式
  • 关注问题和上下文
• View: 一些元素的表示和之间的关系

模块视图：强调静态

• Views:
  • Decomposition View
  • Uses View
  • Generalization View
  • Layered View
  • Aspects View
  • Data model View
• Elements: 提供一致职责的单元，职责内聚的单元
• Relations: is part of/depends on/is a
• Constraints: 不同模块有不同的约束
• Usage:
  • 代码的蓝图
  • 变更影响分析
  • 计划开发
  • 要求可追踪的分析
  • 联系功能和其基于的代码结构
  • 支持工作分配，执行时间表和预算信息的定义
  • 展示系统需要处理的信息结构

C&C视图：强调动态

• Views:
  • Pipe-and-filter View
  • Client-server View
  • Peer-to-peer View
  • SOA View
  • Publish-subscribe View
  • Shared-data View
• Elements: Components(进程和数据) & Connectors(连接Components)，运行时的情况
• Relations:
  • Attachment依附
  • Interface delegation接口委托
• Constraints:
  • 组件只能直接依赖于连接件
  • 连接件只能直接依赖于组件
  • 联系只能在兼容的端口和规则下产生
  • 接口委托只能在两个兼容的端口／规则下产生
  • 连接件不能独立存在
• Usage:
  • 展示系统如何运行
  • 以指定的结构和运行时元素的行为指导开发
  • 帮助解释系统运行时质量属性

分配视图：周围环境

• Views:
  • Deployment View
  • Install View
  • Work assignment View
  • Other allocation Views
• Elements: 单元到运行时环境的映射
  • Software element
  • Environmental element
• Relations:
  • Allocated to
• Constraints: 因视图而不同
• Usage:
  • 解释性能、可获得性、安全性
  • 解释分布式开发和团队工作分配
  • 解释并行访问软件版本
  • 解释系统安装的形式与机制

质量视图

• Views:
  • Security View
  • Performance View
  • Reliability View
  • Communication View
  • Exception View

视图文档化

• 建立利益相关者／视图的表格
• 合并视图
  • 确认上面表格中的小视图
  • 找到小视图与更大的视图元素之间的联系以合并视图
• 优先级和分布
  • 分解视图
  • 80/20原则

视图以外的信息

• 文档信息：版本控制
• 文档目录
• 视图之间的映射

为什么要评估

• 大型项目经常要迟交
• 重新设计，大量的返工
• 提早发现问题
• 传播架构的最佳实践
• 为管理层提供更好的技术和项目信息
• 确定培训能对经常发生的问题产生广泛影响的领域
• 提高与COTS组件供应者的交互

什么时候评估

• 获取阶段
• 演化／更新阶段
• 设计阶段
• 构建阶段

评估方法

• SAAM
• ALMA
• PASA
• ATAM

方法的帮助

• 识别风险
• 发现敏感点
• 发现权衡点

ATAM

• 评估人员：设计者、伙伴、外界人士
• 阶段0: 参与者和准备阶段
  • 参与者：评估小组领队和决策者
  • 输入：体系结构文档
  • 输出：评估计划
• 阶段1: 评估1
  • 参与者：评估小组和决策者
  • 输出：
    • 架构简要报告
    • 商业目标
    • 质量属性和场景
    • 质量属性效用树
    • 风险和非风险
    • 敏感点和权衡点
  • 步骤：
    • 表述ATAM
    • 表述商业动机
    • 表述架构
    • 确定使用的架构方法
    • 生成质量属性效用树
    • 分析架构方法
• 阶段2: 评估2
  • 参与者：评估小组，决策者和利益相关者
  • 输出：
    • 一个从利益相关者集团来的优先级场景列表
    • 风险、商业动机
  • 步骤：
    • 表述ATAM和先前的结果
    • 头脑风暴，划分场景优先级
    • 分析架构方法
    • 展示结果
• 阶段3: 后续工作
  • 参与者：评估小组和决策者
  • 输出：
    • 最终评估报告

SPL

• 很多不同但是相关近似的商品
• Products：Custom Assets（自定义资产） 和 Core Assets（核心资产）
• 具有一组可管理的公共特性的软件密集性系统的合集，这些系统满足特定的市场需求或任务需求，并且按预定义的方式从一个公共的核心资产集开发得到

可复用性和可修改性

• 减少LOC
• 复用：代码复用是最容易的
• 变动：让代码更加灵活，现在设计，将来复用
  • 根据市场定义产品线范围
  • 设计PLA符合产品线范围
  • 使用重用和变化机制

PLA

• 复用：find, understand, and use(invoke)
• variation:
  • Forms of variation 6
    • 包含或删除元素Include or omit elements
    • 每个元素的可变性Variable number of each element
    • 满足接口Interface Satisfaction
    • 参数化Parameterisation
    • 接口挂钩“Hook” interfaces
    • 反射Reflection
  • Software entity varied 3
    • Architecture level – High-level abstract structures
    • Design level – Lower-level abstract structures
    • File level – low-level concrete source structures
      • Binding time 5
    • Coding-time – when you create a coding workspace
    • Compile-time – when you build object code
    • Link-time – when you create your application
    • Initialization-time – when your application starts
    • Run-time – while your application is running

Produce Line Approach

• 3 Essential Activities
• 29 Practice Areas
• 12(22) Practice Patterns

Software Design Practices

• transformation step改造步骤
• elaboration step细化步骤，重组设计模式
• one transformation step, usually preceded and followed by elaboration steps
• (de-)composition methods自上而下分解／识别实体
• organization methods受功能需求影响，尊从非功能需求
• template-based methods提供标准策略

Incremental Development递增开发

• RAD快速应用开发（敏捷）
• DSDM动态系统开发方法
  • MoSCoW
  • Feasibility Study可行性研究，是否适合
  • Business Study商业研究，着眼于业务流程组织
  • Functional Model Iteration功能模型迭代，开发的“黑箱”模型系统
  • Design and Build Iteration设计和构建的迭代，混合“白盒”和原型
  • Implementation phase实现阶段，包括用户培训和评估

SSA／SD结构化系统分析与结构化设计

• initial DFD（数据流图）描述（上下文图）
• 分层数据流图
• Transaction Analysis交易分析，将DFD分为易于理解的单元
• Transform Analysis变化分析，建立结构图
• 合并结构图创造基础实现计划

JSP

JSD

(Entity-)Structure diagram, Data-flow stream, State-vector; Modeling, Network, Implementation

Summary

Software Design Practices

• Design Strategies

  • 在两个transformation step之间由elaboration step优化
  • 低层(de-)composition
  • 基于标准template-based

• Incremental Design

  • RAD, SDSM：functional model, design & build
• Structured Systems Analysis and Structured Design(SSA/SD)
  • 前面进行分析
  • 后面进行迭代
  • Structure chart

1. 概述

什么是企业应用

企业应用程序是分布式的、事务的和轻便的应用程序，利用服务器端技术的速度、安全性和可靠性，为企业提供业务逻辑。

1. 企业应用程序为企业提供了业务逻辑
2. 企业应用通常是集中管理的，经常与其他企业软件进行交互
3. 在信息技术领域的应用，企业应用必须以更少的成本，更高的速度和更少的资源来进行设计、建造和开发

J2EE多层式应用模型

可以分为4层：

• 运行在客户机上的客户层
• 运行在J2EE服务器上的web应用层
• 运行在J2EE服务器上的业务逻辑层

• 运行在EIS服务器上的企业信息系统层

  一般，J2EE应用程序被认为是三层体系结构，因为主要分布在三个地方：客户端、服务器端、数据库或是后台的遗留层。

什么是组件

J2EE组件是一个独立的软件功能单元，与它相关的类和文件一起组织进J2EE应用，并与其他组件通讯。

J2EE组件与Java组件的区别

Java EE组件与其他Java标准类的区别在于，Java EE将装配至一个Java EE应用中并通过验证，以保证其满足Java EE规范要求，从而可以部署在生产环境中。生产环境是一个Java EE服务器并可以管理Java EE组件的地方。

每一层分别有哪些组件

1. Application clients and applets(Java EE Client)
   • Web clients, Application clients, Applets, JavaBean Components
2. Web components
   • Servlets, web pages, JSP
3. Business components
   • EJB
4. EIS层
   • 数据库和后台遗留层

J2EE运行时环境／容器

容器是组件与底层平台功能间的接口。在Web组件、企业Bean或应用程序客户端运行之前，必须将其装配至Java EE模块并部署到容器中。

容器提供哪些服务

security, transaction management, Java Naming and Directory Interface (JNDI) lookups, and remote connectivity.
安全，事务处理，JNDI查找和远程连接。

容器的可配置和不可配置服务

• J2EE安全模型让你可以配置Web组件或者是企业Bean，以保证资源只能被授权用户访问。
• J2EE事务模型让你指定属于同一个事务的多个方法以使这些方法作为一个原子操作被执行。
• JNDI查找服务为企业应用中的多种命名和目录服务提供统一接口，使应用程序组件可以统一访问这些命名和目录服务。
• J2EE远程连接模型管理客户端和企业Bean之间的底层通信。企业Bean被创建后，客户端调用它的方法就像在本地虚拟机中的调用一样。
• 容器也管理着很多不可配置的服务，如企业Bean和Servlet的生命周期，数据库连接池，数据持久化机制和J2EE平台API的访问权等等。

容器的类型

1. Java EE Server
   • EJB Container
     • 管理Java EE应用企业Bean的执行。
   • Web Container
     • 管理Java EE应用的Web pages, Servlets, 和其他一些EJB组件的执行。
2. Application Client Server
   • 管理客户端组件的执行
3. Applet Container
   • 管理Applets的执行

J2EE打包成三种文件

• Java Archive(JAR) file
• Web Archive(WAR) file
• Enterprise Archive(EAR) file
• war和ear都是jar只是加上了扩展名

一个标准的J2EE模块包含哪些部分

• 功能性的一个或多个组件

• 可选的部署描述文件

• Web模块

  • *.war
  • 包括servlet类文件，JSP页面文件，支持类文件，GIF和html文件，XML配置文件
  • resources
    • html
    • css
    • js
    • …
  • WEB-INF
    • web.xml
    • *.xml
    • classes
    • tld
    • lib
    • …

• EJB模块

  • *.ear
  • 包括ejb文件，ejb配置文件
  • application client模块：*.jar，包括相关类文件，程序客户端配置文件

  • resource adapter模块：*.rar，包括所有的java接口，类，本地库和文档和资源适配描述文件

    

2. Web应用

什么是Web应用

Web应用是Web应用服务器的动态拓展，有面向服务的和面向表现的两种类型。

• Presentation-oriented
  • 通过标记语言和对请求响应的动态内容生成可交互Web页面
• Service-oriented
  • 面向服务的Web应用程序实现Web服务的端点

一般来说，一个Web应用可以看成是一组安装在服务器URL名称空间的特定子集下面的Servlet的集合。

请求处理过程

1. 客户端向Web服务器发送一个http请求
2. 实现了Java Servlet和Java Server Pages技术的服务器将请求转换为一个HttpServletRequest对象
3. 这个对象被投递到一个Web组件，这个组件可以与JavaBeans组件或者一个数据库交互生成一个动态内容(dynamic content)
4. 这个组件可以生成一个HttpServletResponse或者将这个请求转发给其他Web组件
5. Web组件最终生成一个HttpServletResponse对象
6. Web服务器将这个对象转换成http应答消息返回给客户端

Web容器提供哪些服务

• request dispatching（请求分发）, security（安全）, concurrency（并发）, and lifecycle management（生命周期管理）
• Web容器同时也为Web组件提供了获取命名、事务、邮件（naming, transactions, and email）的API的方式
• Java EE annotations和部署配置文件进行配置

Web模块包含哪些内容

• Web组件、web资源
• 帮助类库(Helper classes and libraries)
• 服务器端实用工具类（utility classes，例如database beans，shopping carts等）
• 客户端类（applets和utility classes）

Web资源有哪些

包含Web部件和静态网页内容的文件如图像的Web模块被称为网络资源

Web模块的目录结构

1. 根目录document root：存放html，XHTML页面，客户端类和文档，静态资源例如图片等的目录；
2. WEB-INF目录：
   • 已经编译的class服务器端的类文件夹（servlets, enterprise bean class files, utility classes, and JavaBeans components）
   • tags标签文件夹
   • lib引用类库文件夹
   • 配置类文件（例如web.xml，ejb-jar.xml）

Tomcat组件

1. Server: 代表一个服务器

2. Connector：在某一个指定端口监听用户请求，并且将获得的请求交给engine来处理

   • Java HTTP Connector在端口8080侦听来自客户Browser的http请求
     • AJP 1.3 Connector在端口8009侦听来自其他Web Server(Apache)的JSP/Servlet代理请求

3. Engine：将获得的请求匹配到某个虚拟主机上，并且吧请求交给该host来处理

4. Host：代表虚拟主机，每一个都和某个网络域名想匹配，每一个都可部署多个web应用
5. Context：对应一个Web应用（由一些Servlet，HTML，Java类，JSP页面和一些其他的资源组成，在创建时根据在获得\/conf/web.xml和\/WEB-INF/web.xml载入Servlet类。在请求时查询映射表找到被请求Servlet类并且执行以获得请求回应）

Tomcat请求处理流程

1. 请求被发送到本机端口8080,被Java HTTP Connector获得
2. Connector将该请求交给它所在的service的Engine来处理并等待Engine的回应
3. Engine获得请求，匹配所有的虚拟主机
4. Engine匹配到名为localhost的主机
5. Localhost主机获得请求，匹配所拥有的所有Context
6. Localhost主机匹配到路径为/HelloWorld的Context
7. 路径为/HelloWorld的Context获得请求，在映射表中寻找对应的servlet
8. Context匹配URLPATTERN为/的Servlet
9. 构造HttpServletRequest对象和HttpServletResponse对象，作为引用调用该Servlet的Service方法
10. Context把执行完后的HttpServletResponse返回给localhost主机
11. Host把HttpServletResponse对象返回给Engine
12. Engine把HttpServletResponse对象返回给Connector
13. Connector把HttpServletResponse对象返回给客户Browser

3. Servlet

Servlet

Servlet是Java编程语言的类，用于扩展采用请求响应模式的服务器应用程序容量。

Servlet生命周期

Servlet的生命周期由Servlet所部署的容器控制。
当一个客户端请求发送到服务器时，容器开始执行以下步骤：

1. 如果servlet实例不存在Web容器会：
   • 载入servlet类
   • 创建一个servlet的实例
   • 调用init方法初始化这个实例
2. 然后调用service的方法，传递request和response对象

如果容器需要移除这个servlet，那么他就会通过调用servlet的destroy方法来释放这个servlet。

什么是URL Pattern

一个用于定义web组件或者例如图片，html页面这类静态对象的字符串。

请求URL

URL包含以下部分：
http://[host]:[port][request-path]?[query-string]

请求路径由以下元素组成:

• Context path: 向前的斜线/和servlet的Web应用的上下文根的拼接
• Servlet path: 与激活该请求的组件别名相应的路径部分，由向前的斜线/开始
• Path info: 请求路径的部分，不是上下文路径或者servlet路径的部分

Http请求，URL组成部分包括哪些元素？

采用请求响应模型，request（从客户端到服务器端），response（从服务器端到客户端）

1. Request包括：

request方法（包括GET，HEAD，POST，PUT，DELETE，OPTIONS，TRACE）
requestURL（一个字符串，由它来导向一个web组件，或者是一个静态的对象，例如html页面或者是图片文件什么的）
header fields
body

1. Response包括：

result code（例如404（表示请求资源不可用），401（请求需要HTTP认证），500（服务器内部错误导致无法完成请求）503（服务器超载导致无法完成请求））
header fields
body

URL和URI的区别

URL是一种具体的URI，它不仅唯一标识资源，而且还提供了定位该资源的信息。
URI是一种语义上的抽象概念，可以是绝对的，也可以是相对的，而URL则必须提供足够的信息来定位，所以，是绝对的。

如何处理Servlet的线程安全问题

可以使用同步机制

1. Servlet默认是多线程的，Server创建一个实例，用它处理并发请求——编写线程安全的类，避免使用可以修改的类变量和实例变量
2. 实例变量是在堆中分配的，不是线程安全的；
3. Request，response是线程安全的
4. 局部变量是在栈中分配的，是线程安全的（局部变量可以作为参数传递）
5. 实现 SingleThreadModel接口：该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。
6. 同步对共享数据的操作：使用synchronized关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中的Servlet可以通过同步块操作来保证线程的安全。

Http Session会话机制

• Cookie机制
  1. 当用户第一次访问站点→创建一个新的会话对象（Httpsession）， Server分配一个唯一的会话标识号(sessionID)
     • Servlet容器自动处理sessionID的分配
     • 尽可能长，确保安全
     • 把sessionID信息放到HttpSession对象中
  2. Server创建一个暂时的HTTP cookie
     • cookie存储这个sessionID（名:jsessionid）
     • Server将cookie添加到HTTP响应中
     • Cookie被放置到客户机浏览器中，存储到客户机硬盘
  3. 客户浏览器发送包含Cookie的请求
  4. 根据客户机浏览器发送的sessionID信息（cookie），Server找到相应的HttpSession对象，跟踪会话
  5. 在会话超时间隔期间，如果没有接收到新的请求， Server将删除此会话对象
     • 用户又访问该站点，必须重新登录，确保安全
• URL重写
  1. 1、5与Cookie机制相同
  2. Server将sessionID放在返回给客户端的URL中
  3. 客户浏览器发送的请求将包含sessionID
  4. 根据包含请求的sessionID信息（URL），Server找到相应的HttpSession对象，跟踪会话

Cookie和Session两者应用上的区别

• Cookie

  1. 跟踪会话，也可以独立于http会话使用cookie
  2. 长期“记住用户信息”

  3. 存储在本地计算机硬盘上

     用户登录ID
     用户对语言和颜色的选择之类的偏好
     跟踪应用程序的使用情况
     cookie.txt文件

• Session

  1. 保存在服务器端内存中

  2. 使用机制不同

     跟踪用户的购物车
     导航信息，登录状态

Web组件共享信息的方式

• 通过使用私有的帮助对象（helper objects），比如：JavaBeans components
• 通过共享公共作用域的对象属性（objects that are attributes of a public scope）
• 可以使用数据库
• 可以调用其它网络资源

Web组件共享信息的四种作用域对象

• Web Content
  • 作用域为应用程序运行期，工程启动后存在，当容器关闭时被销毁
• Session
  • 作用域为会话期，从打开一个浏览器窗口开始，关闭窗口，会话关闭，当会话超时，被销毁
• Request
  • 作用域为用户请求期，只要Server向客户端输出内容，就被销毁
• Page
  • 作用域为页面执行期

过滤器，与其他Web组件的区别

• 过滤器是一个可以改变请求或响应的标题或者内容的对象。
• 过滤器和其他web组件不同的地方在于，过滤器通常不需要自己创建一个响应，相反，他们提供可以附加于任何类型的网络资源上的功能。
• 应用场景
  • 改善代码重用，在不修改servlet代码的情况下想servlet添加功能
    • 身份验证
  • 用于跨多个servlet执行一些功能，创建可重复使用的功能
  • 在servlet处理请求之前截获请求
    • 在调用servlet之前截获请求，验证用户身份，未经授权的用户遭到拒绝，而servlet不知道曾经有过这样的请求
  • 代码重用、应用安全策略、日志、为特定目标浏览器传输XML输出、图像转换和加密、动态压缩输出

J2EE监听器

监听器是当生命周期时间发生前、发生后进行一些处理。

可以监听的生命周期事件：

• Web Context
  • 初始化和销毁
  • 属性的添加、移除或替换
• Session
  • 创建，失效，活化，钝化，超时
  • 属性的添加、移除或替换
• Request
  • 一个servlet请求开始被web组件处理
  • 属性的添加、移除或替换

1. 监听系统关闭或者是开启
2. 监听用户访问次数
3. 监听用户是否登录
4. 监听session是否改变等

部署描述文件和注解的区别

• 注解往往是类级别的，因此，XML 配置则可以表现得更加灵活
• 在应用中，往往需要同时使用注解配置和 XML 配置
  • 对于类级别且不会发生变动的配置可以优先考虑注解配置
  • 而对于那些第三方类以及容易发生调整的配置则应优先考虑使用 XML 配置

4. JSP页面

JSP

JSP允许创建包括静态和动态组件的web内容。servlet是JSP的基础，JSP提供了所有servlet可以实现的动态功能，并且还提供一种更加自然的静态内容的创建方法。

• 静态数据
  • HTML, SVG, WML and XML
  • 静态数据转换成将数据发送到响应流中的代码
• JSP元素
  • Directives指令用于控制web容器如何翻译和执行JSP页面
  • Scripting elements脚本元素插入该JSP页面的servlet类中
  • Expression language表达式作为参数传递给JSP表达式解释器
  • jsp:[set|get]Property转换成方法调用JavaBeans组件
  • jsp:[include|forward]转换成Java Servlet API的调用
  • jsp:plugin被转换成浏览器特定的标记，用于激活一个applet
  • Custom tags自定义标签调用标记处理程序实现自定义标签调用

JSP生命周期

JSP页面以Servlet的形式提供请求服务，所以，JSP的生命周期和许多JSP功能都是由Servlet技术决定的（特别是动态的方面）

1. 如果JSP页面的servlet实例不存在，容器将：
   • 加载该JSP页面的servlet类
   • 实例化servlet类的实例
   • 通过调用jspInit方法初始化servlet实例
2. 容器调用_jspservice方法，传递请求和响应对象
3. 如果容器需要移除JSP页面的servlet，它调用jspDestroy方法

指令元素

• page指令：可以通过Page指令来控制各种JSP页面执行参数
  • <jsp:directive.page attribute list/>
  • <%@ page property-attribs%>
  • 参数包括：
    • session是否创建session
      • <%@ page session= "true" %>
    • import引用依赖
      • <%@ page import= "package.*" %>
    • extends扩展其他类
      • <%@ page extends= "com.learnweblogic.JspCommon" %>
    • contentType设置文本类型和字符编码
      • <%@ page contentType= "text/html,charset=GBK" %>
    • buffer设置缓冲区
      • 缺省情况下：写入输出流的内容会立即发送给客户
      • <%@ page buffer="none|xxxkb" %>
    • isThreadSafe
      • isThreadSafe= “true|false”
      • false意味着一次只能有一个线程执行JSP中的代码
    • errorPage
      • <%@ page errorPage="file-name" %>

• include指令：当JSP页面被转换成Servlet时被处理，实现JSP页面的模块化，使JSP的开发和维护变得相当简单

  • <jsp:directive.include file="filename"/>
  • <%@ include file="filename" %>

  • 相当于

    1 2 3

    RequestDispatcher dispatcher=getServletContext().getRequestDispatcher("/banner.jsp"); if(dispatcher!=null) dispatcher.include(request,response);

• Taglib指令

  • <%@ taglib uri="uri" prefix="tagPrefix" %>

脚本元素

• 声明

  • 声明的变量只在当前页面中可用<%! int foo=3; %>

    1 2 3 4 5

    <%! public void jspInit() { …… } %>

• 脚本

  • 1 2 3

    <% scripting-language-statements %>

• 表达式

  • <%= scripting-language-expression %>

脚本元素中创建和使用对象的方法有哪些？这些对象在翻译时如何进行处理？

• 类实例和类变量：在声明中创建，在脚本和表达式中被使用
• 局部变量：在脚本和表达式中被创建和使用
• 作用域对象的属性：在脚本和表达式中被创建和使用

JSP常用隐式对象

1. Out对象
   • 做PrintWriter对象能做的一切事情
   • 调用print()/println()方法，把信息回送给客户端浏览器
   • 作用域是当前页面（page）
   • 每个JSP页面有一个out对象的实例
   • 缺省采用缓存，可以使用page指令调整其大小
2. Request对象
   • 使用request对象得到请求信息中的参数
3. Response对象
   • 使用response对象发送重定向、修改HTTP头、指定URL重写
4. Session对象
   • javax.servlet.http.HttpSession的实例
5. Application对象
   • 从web.xml获取初始化参数、访问RequestDispatcher
6. PageContext对象
   • 对页面作用域的属性的访问

JSP动作

• 可以使用脚本执行动作提供的任何功能
• 动作改进了脚本，易于使用，帮助摆脱java代码

1. <jsp:include>
   • <jsp:include page= " Copyright.html" />
   • 与include指令的区别
     • include指令：包括其他页面，编译时把其他页面的内容加进来，比include动作快
     • include标准动作：使用RequestDispatcher，运行时把其他页面的内容加进来（包括到输出流中）
2. <jsp:forward>
   • <jsp:forward page= " foo.jsp" />
   • 与HTTP重定向的差别
     • HTTP重定向：发送的请求信息又回送给客户机，让客户机再转发到另一个资源上，新的URL出现在Web浏览器中，需要在服务器和客户机之间增加一次通信
     • forward标准动作：使用RequestDispatcher ，JSP的转发功能是在服务器本身上实现的

3. <jsp:param>

   1 2 3 4 5

   <jsp:include page= " /itemdetail.jsp" > <jsp:param name= " itemid " value= " %=itemId" /> </jsp: include > ``` 4. `<jsp:plugin>`

   
   
   ```

4. <jsp:useBean>``<jsp:sebProperty>``<jsp:getProperty>

Java Bean组件的设计规范

1. 一个JavaBean组件属性必须是
   • Read/write, read-only, or write-only
   • 简单，也就是说它只包含一个数值或一个索引（即指代表一个数组）
2. 必须使用符合下列约定的public方法来访问
   • 对每一个可读的属性，具有方法：PropertyClass getProperty() {...}
   • 对每一个可写的属性，具有方法：setProperty(PropertyClass pc) {...}
3. Java Bean还需要有一个无参构造函数

Java Bean组件的作用域

1. application
   <jsp:useBean id="locales" scope="application" class="mypkg.MyLocales"/>
2. session
3. request
4. page

5. EJB

什么是EJB

企业bean是用Java编程语言编写的一种服务器端组件用于封装应用程序的业务逻辑。

• Session Bean：为客户端执行某个任务，也有可能实现一个Web服务，封装业务逻辑，可以被本地的或者远程的客户端以及网络服务客户端的页面（web service client views）
  • Session Bean封装了实现的复杂度，但Session Bean不是持久的
• Message-driven Bean：为一个特定的事件充当监听（如Java Message Service API）
  • 允许Java EE异步处理信息，可以处理JMS消息或者其他类型的消息
  • 消息可以由任何的Java EE组件发送（应用客户端、其他EJB、Web组件），或者由JMS应用以及不使用Java EE技术的系统

Session Bean

• Stateful
  • 代表了一个唯一的client与bean的一次会话，不共享。当bean的状态代表了特定的client与bean的交互、bean需要在跨方法调用的范围内保存client的信息、bean调解（中介）client与其他应用组件、bean在幕后管理几个enterprise bean的工作流时使用
• Stateless
  • bean不保存与client的交互状态，只在一个方法调用的范围内维护client的信息，调用结束后状态消除。一个stateless session bean可以实现一个web service，而这是stateful session bean无法做到的。当bean没有某个特定client的信息、bean在一个方法调用内为所有client执行通用任务、bean实现了web service时使用
• singleton
  • 对每个应用只实例化一次，并存在于整个应用的生命周期内。为一个enterprise bean被许多client并发访问、共享的场景所设计。如同stateless session bean，singleton session bean也可以实现web service。通常用来执行初始化任务与清除任务

客户端获取Bean的引用

1. JNDI查找
   • 一个在Java EE服务器托管的环境外运行的应用，如Java SE应用程序必须执行一个明确的查找
2. 依赖注入
   • 客户端运行在Java EE服务器托管环境下，JSF Web应用，JAX-RS Web服务，其他企业Bean，或是Java EE应用客户端，支持使用javax.ejb.EJB注释进行依赖注入

客户端的类型

• Remote
  • 它可以运行在不同的机器和不同的JVM从企业bean它访问
  • 它可以是Web组件、应用程序客户端或其他企业bean
  • 对于远程客户机，企业bean的位置是透明的
  • 企业bean必须实现业务接口，也就是说，远程客户端可能无法通过无接口视图访问企业bean
• Locate
  • 它必须运行在与它访问的企业bean相同的应用程序中
  • 它可以是一个Web组件或另一个企业bean
  • 对于本地客户端，企业bean访问的位置不透明
• web service

打包文件结构

6.JPA

什么是JPA

提供对象/关系型数据库的映射功能，完成数据持久化

什么是实体类

一个轻量级的持久化领域对象。
通常，实体表示关系数据库中的表，并且每个实体实例对应于该表中的一行。
持久数据组件——内存中的对象，对应到数据库中的一个视图；一种持久性的、事务性的以及可以共享的组件，多个客户机可以同时使用其中的业务数据。

一个普通的POJO类通过@Entity可以映射成为可持久化的类，类JavaBean风格
类属性必须为private；
有Getter和Setter方法；
有一个无参的构造方法。
@Entity：表明是实体类
@Table：映射到那张表
@Id：主键
@Column：映射字段

实例的四种状态

• new

  • 通过new生成一个实体对象如：
    User user=new User(“001”,“xyz”,……);
    user通过JVM获得了一块内存空间，但是并没有保存进数据库，还没有纳入JPA EntityManager管理中，在数据库中==不存在==一条与它对应的记录

• managed

  • 纳入JPA EntityManager管理中的对象。new状态的对象，可通过persist()方法把user与数据库相关联，成为==持久化对象==；或使用find()方法，得到持久化对象。在数据库中存在一条与它对应的记录，并拥有一个持久化标识 (identifier)，对持久化对象的操作，==影响数据库==
• detached
  • 游离对象。例如：find()方法调用后，可关闭EntityManager，成为游离对象，如: em.clear()
  • 对游离对象的操作，==不影响==数据库。和new状态的区别，在数据库中可能还存在一条与它对应的记录，只是现在这个游离对象脱离了JPA EntityManager的管理。游离对象转为持久对象调用merge()方法
• removed
  • remove()方法，删除数据库中的记录在适当的时候被垃圾回收

7. 安全

容器提供两种安全方式

• 声明式
  • 声明式安全通过使用部署描述或注释来表达应用程序组件的安全性要求。
  • 部署描述对于一个应用来说是外在的，包括了具体描述安全角色和访问要求向具体的环境安全角色、用户和策略的映射关系
  • 在j2ee平台中部署描述符充当了说明的安全性的主要工具。部署描述符是组件开发者和应用程序部署者或应用程序组装者之间的交流工具。应用程序的开发者用它来表示应用中的安全需求，应用程序部署者或应用程序组装者将安全角色与部署环境中的用户和组映射起来。在程序运行时容器从部署描述符中提取出相应的安全策略，然后容器根据安全策略执行安全验证。说明的安全性不需要开发人员编写任何安全相关的代码，一切都是通过配置部署描述符来完成的
• 编程式
  • 嵌入在应用中被用来作出安全决策
  • 在只使用声明式安全不足以满足应用的安全模型的时候非常有用

声明式安全声明了哪些与安全配置相关的信息

information that specifies how security roles and access requirements are mapped into environment-specific security roles, users, and policies.（具体描述安全角色和访问要求向具体的环境安全角色、用户和策略的映射关系）

安全性

• 用户和组
  • 用户：应用程序终端用户的账户名（ID）
  • 组：命名的用户集合，可以包含0个或多个用户；通常用于表示具有类似系统资源访问权限的应用程序用户
    • “雇员”组：企业的所有用户
    • “管理人员”组： “雇员”组的子集，可以访问敏感的工资数据
• 认证和授权
  • 认证（Authentication）：用户向系统证明“我是谁”
  • 授权（Authorization）：应用服务器授予某个用户访问哪些资源的权限，“我能访问什么样的服务”
• 角色和策略
  • 角色(role)：一种抽象的逻辑用户分组；代表相同资源访问权限的用户组或者特定用户；
  • 在部署时，角色被映射为授权的用户或组
  • 策略：回答“特定角色能够访问什么样的服务”的问题
• 审计和日志记录
  • 收集、存储和分发整个系统中安全事件信息
  • 查看执行的活动；
  • 帮助检测和调查应用程序环境中的潜在弱点
• 防火墙
  • 禁止任何不需要的协议或客户类型访问应用程序
• 数据保密和安全套接字
  • 安全套接字层（Secure Sockets Layer, SSL）：通过在网络传输之前对数据加密，保证数据的机密性
  • SSL结合了几种加密技术：数字证书、标准加密（对称密钥加密）、公钥加密

认证方式

• HTTP基本验证（HTTP Basic Authentication）
• 基于表单的验证（Form-Based Authentication）
• 基于客户端证书的验证（Client-Certificate Authentication）即通过HTTPS（HTTP over SSL）来保证验证的安全性
• 摘要认证Digest authentication
• 相互认证Mutual authentication

8. 总体设计

MVC

架构

• 模型：封装应用数据（关系数据库或EJB），处理商业逻辑
• 视图：呈现给用户的界面（JSP或应用GUI）
• 控制器：接受用户动作，并对应用数据进行适当的处理（Servlet）

控制流程

1. client发起一个请求（浏览器）
2. servlet获得请求
3. servlet决定哪一个程序元素（JavaBeans, EJBs or other objects）该执行该请求
4. JavaBeans或EJBs为servlet执行业务逻辑，并封装结果
5. servlet决定展示模板（jsp）以便将内容返回给client
6. jsp根据从JavaBeans获得的结果集生成具体内容
7. 返回并展示

SSH框架

总体结构

struts

整合后的执行流程：

• 客户端初始化一个指向servlet容器的请求
• 请求经过一系列的过滤器（ActionContextCleanUp用来清除ac）
• FilterDispatch被调用，去查询ActionMapper来确定是否去调用某个action
• 如果要调用某个action， filterdispatch将该请求交给Action Proxy
• Action Proxy通过 Configuration Manager 找到需要调用的Action
• Action Proxy创建ActionInvocation对象副本
• ActionInvocation回调action的execute方法
• action中已通过spring注入业务逻辑对象（**Bean），action的execute方法调用**Bean的业务逻辑方法
• **Bean中已通过spring注入了数据访问层对象（**DAO），**Bean执行业务逻辑，调用**DAO的方法
• **DAO通过hibernate与数据库进行交互，返回信息
• **bean返回信息
• action根据返回结果选择该展示的模板（jsp），设置好数据，返回相应字符串
• 一旦执行结果返回结果字符串，ActionInvocation负责查找结果字符串对应的Result然后执行这个Result会调用一些模版（JSP）来呈现页面
• 之后拦截器(Interceptor N)会被执行(顺序和Action执行之前相反)
• 最后响应(HttpServletResponse)被返回给在web.xml中配置的那些过滤器和（核心控制器）（FilterDispatcher）。

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment