jsf托管bean可以像servlet一样运行吗？(Can a jsf managed bean behave like a servlet?)

 据我了解你的要求，你想 
 
 
 
 从m1生成一些键序列。 
 
 
 在m2中，将这些键序列中的每一个与特定的常数值相关联。 
 
 
 第一步是对m1进行相当简单的转换。 我们希望为每个条目生成0个或更多的key-seq （取决于它的集合中有多少个），所以对我来说，自然是mapcat 。 它代表map -then- concat ，对于这样的情况来说非常好，即从seq的每个元素中我们生成0个或更多的元素。 
 
(defn key-seqs [coll]
  (mapcat 
   (fn [[k v]] 
     (map (partial vector k) v))
   coll))

(key-seqs m1)
;;=> ([:1 2] [:2 1] [:2 3] [:3 1])
 
 请注意， mapcat采用的函数本身就是一个map ，因此它会为mapcat展开序列 （可能为空）。 但这会将存储在集合中的长点作为自己返回。 如果我们想将它们变成匹配m2关键字，我们需要更多的处理： 
 
(defn key-seqs [coll]
  (mapcat 
   (fn [[k v]] 
     (map (comp (partial vector k) keyword str) v))
   coll))

(key-seqs m1)
;;=> ([:1 :2] [:2 :1] [:2 :3] [:3 :1])
 
 （我们需要使用str因为keyword不知道如何处理long。通常关键字不是数字，而是具有一些符号含义的名称） 
 
 然后我们可以适应先前问题中的update-m一点，以便它可以将常量值作为参数，并处理不仅具有相同值两次的键序列： 
 
(defn update-m [m x v]
  (reduce (fn [m' key-seq]
            (assoc-in m' key-seq x)) ;; accumulate changes
          m   ;; initial-value
          v)) ;; collection to loop over
 
 现在我们似乎在做生意： 
 
(update-m m2 1 (key-seqs m1))
;;=> {:1 {:1 0, :2 1, :3 23}, :2 {:1 1, :2 0, :3 1}, :3 {:1 1, :2 4, :3 0}}

As I understand your requirements you want to
 
 
 
Produce a number of key-sequences from m1.
 
 
In m2 associate each of those key-sequences with a particular constant value.
 
 
The first step is a fairly simple transformation of m1. We want to produce 0 or more key-seqs for each entry (depending on how many are in its set), so the natural go-to for me is mapcat. It stands for map-then-concat and is great for just such a case where from each element of a seq we produce 0 or more of the elements we want. 
 
(defn key-seqs [coll]
  (mapcat 
   (fn [[k v]] 
     (map (partial vector k) v))
   coll))

(key-seqs m1)
;;=> ([:1 2] [:2 1] [:2 3] [:3 1])
 
Note that the function taken by mapcat is itself a map, so that it produces a sequence (possibly empty) for mapcat to unroll. But this is returning the longs stored in the sets as themselves. If we want to turn them into keywords to match m2 we need a little more processing:
 
(defn key-seqs [coll]
  (mapcat 
   (fn [[k v]] 
     (map (comp (partial vector k) keyword str) v))
   coll))

(key-seqs m1)
;;=> ([:1 :2] [:2 :1] [:2 :3] [:3 :1])
 
(We need to use str because keyword doesn't know what to do with longs. Normally keywords are not numbers, but names with some symbolic meaning)
 
Then we can adapt the update-m from your previous question a little bit so that it can take the constant value as an argument and handle key-sequences that don't just have the same value twice:
 
(defn update-m [m x v]
  (reduce (fn [m' key-seq]
            (assoc-in m' key-seq x)) ;; accumulate changes
          m   ;; initial-value
          v)) ;; collection to loop over
 
and now we seem to be in business:
 
(update-m m2 1 (key-seqs m1))
;;=> {:1 {:1 0, :2 1, :3 23}, :2 {:1 1, :2 0, :3 1}, :3 {:1 1, :2 4, :3 0}}