精华内容
下载资源
问答
  • 近期遇到一个由审计引出的需求,需要在系统中导出用户与其所分配的角色权限的对应关系。笔者公司建立了以岗位为管理单位的复合角色。需要定期输出并检查用户对应的岗位权限是否合理。比如,一个用户有总账会计角色...

    近期遇到一个由审计引出的需求,需要在系统中导出用户与其所分配的角色权限的对应关系。笔者公司建立了以岗位为管理单位的复合角色。需要定期输出并检查用户对应的岗位权限是否合理。比如,一个用户有总账会计角色权限,也可能由于工作的原因临时兼任资产会计,这个用户就可以会存在总账和资产两个复合角色的权限。而当临时任务结束时,权限没有及时取消。所以,用户权限检查的目的就在于定期用户梳理用户权限,最大程度保障用户权限的合理性。

    针对需求先自己尝试处理,但只能做到一个一个的输出后再汇总没有达到很好效果。于是寻求帮助,感谢H姓顾问的帮忙,针对需求,提供了一份简要的指导。记录下来,以便后期需要时可以随时使用。

    事务码SUIM-角色-按用户分配

    选择“有效分配”,如果选择“所有角色”的话,就会把一些没有用户分配的角色也导出来,后面滤掉也可以。

    选中所有角色,(选中列),然后点击上面的“用户分配”按钮

    出来的清单,再次全部选中,然后点击上面的“角色”按钮

    即可出现所有用户的和角色的对应关系,

    然后通过对角色列过滤复合角色(通过复合角色名称关键字如ZDBA_MR*开头)即可。

    出来的结果就是用户有ZDBA_MR*复合角色的用户清单和复合角色的对应清单。可进一步下载到本地处理。

     

    展开全文
  • 角色管理就是将项目中的菜单menu的查看权限和每个菜单里的增删改查权限动态管理起来,从而可以有选择给不同等级的用户放开不同的菜单操作权限。 所需要的表 1.角色表【记录添加的角色信息】 2.角色菜单详情表...

    废话不多少直接说思路

    一.角色管理模块

    角色管理模块在项目中起到一个什么作用呢?这是必须了解到的

    角色管理就是将项目中的菜单menu的查看权限和每个菜单里的增删改查权限动态管理起来,从而可以有选择性给不同等级的用户放开不同的菜单操作权限。

    所需要的表

    1.角色表【记录添加的角色信息】

    2.角色菜单详情表【记录角色对应了多少个菜单】

    3.角色菜单明细详情表【记录角色对应的菜单对应了那些页面功能【如增删改查】】

    4.用户表【记录用户基本信息】

    5.用户角色表【记录给用户选择了那些角色】

    6.菜单表【记录页面菜单menu信息】

    7.按钮表【每个菜单里的CURD等菜单必须和此表ID一致】

    关联表实现控制

    1.控制项目菜单查看权限时,在菜单页面根据登录用户ID判断角色动态循环输出菜单信息

    【将角色菜单详情表内连接用户角色表内连接菜单表。关联条件角色,查询条件用户ID】

    2.控制每个菜单CURD等权限,在每个进方法的控制器时先判断是否该用户有该菜单的查或增的权限。

    【将用户角色表内连接角色菜单明细详情表。关联条件角色,查询条件用户ID】

     

    ps:后续再完善项目审批流程设计思路

     

    展开全文
  • 针对上述问题,提出一种角色对称加密算法,利用角色对称加密将用户角色与密钥相关联,构建角色密钥树,不同角色可根据访问控制策略访问对应权限的文件;同时,提出一种基于角色对称加密的云数据安全去重方案,有效...
  • 参考资料 <<从PAXOS到ZOOKEEPER...在上文的选举完成之后,每个zk实例都会根据选举结果进入对应角色,本文主要就是讲述Leader的初始化相关内容。 Leader初始化流程 case LEADING: LOG.info("LEADING"); ...

    参考资料

    <<从PAXOS到ZOOKEEPER分布式一致性原理与实践>>
    zookeeper-3.0.0
    

    Leader角色初始化

    在上文的选举完成之后,每个zk实例都会根据选举结果进入对应的角色,本文主要就是讲述Leader的初始化相关内容。

    Leader初始化流程

    case LEADING:
                    LOG.info("LEADING");
                    try {
                        setLeader(makeLeader(logFactory));                          // 设置成主状态
                        leader.lead();                                              // 接听所有事件请求
                        setLeader(null);                                            // 如果失去当前主  则将主设置为空
                    } catch (Exception e) {
                        LOG.warn("Unexpected exception",e);
                    } finally {
                        if (leader != null) {                                       // 设置为空并重置状态
                            leader.shutdown("Forcing shutdown");
                            setLeader(null);
                        }
                        setPeerState(ServerState.LOOKING);
                    }
                    break;
    

    在角色进入到LEADING时, 此时就会进入生产一个leader实例并调用该leader实例的lead方法进入主角色开始执行。首先查看makeLeader方法。

    protected Leader makeLeader(FileTxnSnapLog logFactory) throws IOException {
            return new Leader(this, new LeaderZooKeeperServer(logFactory,
                    this,new ZooKeeperServer.BasicDataTreeBuilder()));
        }
    

    此时就是初始化了一个新的Leader类并传入QuormPeer实例并初始化了一个LeaderZooKeeperServer实例。

    该类的初始化方法如下;

        Leader(QuorumPeer self,LeaderZooKeeperServer zk) throws IOException {
            this.self = self;
            try {
                ss = new ServerSocket(self.getQuorumAddress().getPort());           // 监听一下本地服务端口
            } catch (BindException e) {
                LOG.error("Couldn't bind to port "
                        + self.getQuorumAddress().getPort());
                throw e;
            }
            this.zk=zk;
        }
    

    主要就是保存对应的实例并监听本地的端口。接着就执行了该类的lead方法。

    leader.lead方法
        void lead() throws IOException, InterruptedException {
            self.tick = 0;                                                              // 计数置零
            zk.loadData();                                                              // zk加载数据 主要就是将会话删除旧的恢复可用的
            zk.startup();                                                               // zk创建会话 并注册调用链处理函数
            long epoch = self.getLastLoggedZxid() >> 32L;                               // 获取epoch 值 并加1
            epoch++;
            zk.setZxid(epoch << 32L);                                                   // 设置zxid值
            zk.dataTree.lastProcessedZxid = zk.getZxid();                               // 获取最后一次提交事物id
            lastProposed = zk.getZxid();
            newLeaderProposal.packet = new QuorumPacket(NEWLEADER, zk.getZxid(),
                    null, null);                                                        // 生成一个新leader的包
            if ((newLeaderProposal.packet.getZxid() & 0xffffffffL) != 0) {              // 判断值是否为0
                LOG.warn("NEWLEADER proposal has Zxid of "
                        + newLeaderProposal.packet.getZxid());
            }
            outstandingProposals.add(newLeaderProposal);                                // 添加事务
            
            // Start thread that waits for connection requests from 
            // new followers.
            cnxAcceptor = new FollowerCnxAcceptor();                                    // 开启线程接受follower的信息
            cnxAcceptor.start();
            
            // We have to get at least a majority of servers in sync with
            // us. We do this by waiting for the NEWLEADER packet to get
            // acknowledged
            newLeaderProposal.ackCount++;                                               // ack统计 默认包括自己 所有先加1
            while (newLeaderProposal.ackCount <= self.quorumPeers.size() / 2) {         // 检查回复是否大于集群总数的一半
                if (self.tick > self.initLimit) {                                       // 检查tick是否超过限制次数
                    // Followers aren't syncing fast enough,
                    // renounce leadership!
                    shutdown("Waiting for " + (self.quorumPeers.size() / 2)             // 超过限制次数 则停止并返回  并继续进行选举
                            + " followers, only synced with "
                            + newLeaderProposal.ackCount);
                    if (followers.size() >= self.quorumPeers.size() / 2) {              
                        LOG.warn("Enough followers present. "+
                                "Perhaps the initTicks need to be increased.");
                    }
                    return;
                }
                Thread.sleep(self.tickTime);                                            // 休眠
                self.tick++;                                                            // 增加tick 值
            }
            if (!System.getProperty("zookeeper.leaderServes", "yes").equals("no")) {    // 如果获取类熟属性 如果不是leaderServes则设置zk
                self.cnxnFactory.setZooKeeperServer(zk);
            }
            // Everything is a go, simply start counting the ticks
            // WARNING: I couldn't find any wait statement on a synchronized
            // block that would be notified by this notifyAll() call, so
            // I commented it out
            //synchronized (this) {
            //    notifyAll();
            //}
            // We ping twice a tick, so we only update the tick every other
            // iteration
            boolean tickSkip = true;
    
            while (true) {
                Thread.sleep(self.tickTime / 2);                                        // 休眠一半的tickTime时间
                if (!tickSkip) { 
                    self.tick++;
                }
                int syncedCount = 0;
                // lock on the followers when we use it.
                synchronized (followers) {                                              // 获取所有的followers并发送synced请求
                    for (FollowerHandler f : followers) {
                        if (f.synced()) {
                            syncedCount++;
                        }
                        f.ping();                                                       // 发送ping请求
                    }
                }
                if (!tickSkip && syncedCount < self.quorumPeers.size() / 2) {           // 检查是否获得半数以上的回复 如果没有则停止并重新进入选举流程
                    // Lost quorum, shutdown
                    shutdown("Only " + syncedCount + " followers, need "
                            + (self.quorumPeers.size() / 2));
                    // make sure the order is the same!
                    // the leader goes to looking
                    return;
                }
                tickSkip = !tickSkip;
            }
        }
    

    lead方法,主要就是先加载会话相关的数据,然后再注册请求过来的调用链处理函数;在完成之后就进入等待,等待followers发来的确认消息,当获得的响应数超过一半时,就跳出等待;然后就定时检查followers的周期是否超时,并且是否存活,定时给followers发送ping消息。

    FollowerCnxAcceptor获取followers的响应
    class FollowerCnxAcceptor extends Thread{
            private volatile boolean stop = false;
            
            @Override
            public void run() {
                try {
                    while (!stop) {                                                         // 检查是否在运行
                        try{
                            Socket s = ss.accept();                                         // 接受follower的连接请求
                            s.setSoTimeout(self.tickTime * self.syncLimit);                 // 设置该连接的过期时间
                            s.setTcpNoDelay(true);                                          // 是否开启TCP_NODELAY
                            new FollowerHandler(s, Leader.this);                            // 新注册一个FollowerHandler
                        } catch (SocketException e) {
                            if (stop) {
                                LOG.info("exception while shutting down acceptor: "
                                        + e);
    
                                // When Leader.shutdown() calls ss.close(),
                                // the call to accept throws an exception.
                                // We catch and set stop to true.
                                stop = true;
                            } else {
                                throw e;
                            }
                        }
                    }
                } catch (Exception e) {
                    LOG.warn("Exception while accepting follower", e);
                }
            }
            
            public void halt() {
                stop = true;
            }
        }
    

    通过一个线程来完成接受followers的连接,每接受一个连接就初始化一个FollowerHandler,并设置连接的超时时间等条件,并且设置最多网络只有一个未被确认的网络包,依次提高传输效率降低分组的报文个数。

    FollowerHandler的处理流程

    FollowerHandler类就是处理有关消息的发送的相关具体操作类。

        FollowerHandler(Socket sock, Leader leader) throws IOException {
            super("FollowerHandler-" + sock.getRemoteSocketAddress()); 
            this.sock = sock;
            this.leader = leader;
            leader.addFollowerHandler(this);                                    // 添加到leader的followers列表中
            start();                                                            // 开启run方法运行
        }
    

    由于该类继承自线程类,调用start方法就是执行了run函数;

        @Override
        public void run() {
            try {
    
                ia = BinaryInputArchive.getArchive(new BufferedInputStream(sock
                        .getInputStream()));                                                // 初始化接入流
                bufferedOutput = new BufferedOutputStream(sock.getOutputStream());          // 初始化输入流
                oa = BinaryOutputArchive.getArchive(bufferedOutput);
    
                QuorumPacket qp = new QuorumPacket();                                       // 生成一个包
                ia.readRecord(qp, "packet");                                                // 读取输入数据
                if (qp.getType() != Leader.LASTZXID) {                                      // 检查类型
                    LOG.error("First packet " + qp.toString()
                            + " is not LASTZXID!");                                         // 如果不等于最后的事务ID则报错返回
                    return;
                }
                long peerLastZxid = qp.getZxid();                                           // 获取事务ID
                int packetToSend = Leader.SNAP;
                boolean logTxns = true;
    
                long zxidToSend = 0;
                // we are sending the diff
                synchronized(leader.zk.committedLog) {                                      // 如果提交日志的大小不等于0
                    if (leader.zk.committedLog.size() != 0) {
                        if ((leader.zk.maxCommittedLog >= peerLastZxid)                     // 如果当前的最大日志大于接受事务ID
                                && (leader.zk.minCommittedLog <= peerLastZxid)) {           // 并且当前的最小日志小于接受事务ID
                            packetToSend = Leader.DIFF;
                            zxidToSend = leader.zk.maxCommittedLog;                         // 发送日志设置成最大日志
                            for (Proposal propose: leader.zk.committedLog) {                // 遍历获取事务日志
                                if (propose.packet.getZxid() > peerLastZxid) {              // 如果获取的日志大于当前接受的事务ID
                                    queuePacket(propose.packet);                            // 将数据发送给followers同步数据
                                    QuorumPacket qcommit = new QuorumPacket(Leader.COMMIT, propose.packet.getZxid(),
                                            null, null);
                                    queuePacket(qcommit);                                   // 添加到发送队列中
    
                                }
                            }
                        }
                    }
                    else {
                        logTxns = false;
                    }            }
                long leaderLastZxid = leader.startForwarding(this, peerLastZxid);           // 加入到要处理的列表中
                QuorumPacket newLeaderQP = new QuorumPacket(Leader.NEWLEADER,
                        leaderLastZxid, null, null);                                        // 生成一个新的包
                oa.writeRecord(newLeaderQP, "packet");                                      // 发送该包
                bufferedOutput.flush();
                // a special case when both the ids are the same
                if (peerLastZxid == leaderLastZxid) {                                       // 检查事务ID与当前最后的事务ID是否相同
                    packetToSend = Leader.DIFF;                                             // 检查日志是否有不一样的
                    zxidToSend = leaderLastZxid;
                }
                //check if we decided to send a diff or we need to send a truncate
                // we avoid using epochs for truncating because epochs make things
                // complicated. Two epochs might have the last 32 bits as same.
                // only if we know that there is a committed zxid in the queue that
                // is less than the one the peer has we send a trunc else to make
                // things simple we just send sanpshot.
                if (logTxns && (peerLastZxid > leader.zk.maxCommittedLog)) {
                    // this is the only case that we are sure that
                    // we can ask the follower to truncate the log
                    packetToSend = Leader.TRUNC;                                           // 截断日志
                    zxidToSend = leader.zk.maxCommittedLog;
    
                }
                oa.writeRecord(new QuorumPacket(packetToSend, zxidToSend, null, null), "packet");       // 写入新的包确定了类型与ID值
                bufferedOutput.flush();
                // only if we are not truncating or fast sycning
                if (packetToSend == Leader.SNAP) {                                          // 如果数据没有改变
                    LOG.warn("Sending snapshot last zxid of peer is 0x"
                            + Long.toHexString(peerLastZxid) + " " 
                            + " zxid of leader is 0x"
                            + Long.toHexString(leaderLastZxid));
                    // Dump data to follower
                    leader.zk.serializeSnapshot(oa);                                        // 将序列化快照发送给follower
                    oa.writeString("BenWasHere", "signature"); 
                }
                bufferedOutput.flush();
                //
                // Mutation packets will be queued during the serialize,
                // so we need to mark when the follower can actually start
                // using the data
                //
                queuedPackets
                        .add(new QuorumPacket(Leader.UPTODATE, -1, null, null));            // 添加到队列中
    
                // Start sending packets
                new Thread() {
                    public void run() {
                        Thread.currentThread().setName(
                                "Sender-" + sock.getRemoteSocketAddress());
                        try {
                            sendPackets();                                                  // 启动线程发送数据
                        } catch (InterruptedException e) {
                            LOG.warn("Interrupted",e);
                        }
                    }
                }.start();
    
                while (true) {
                    qp = new QuorumPacket();                                                // 生成一个包
                    ia.readRecord(qp, "packet");                                            // 读包的数据
    
                    long traceMask = ZooTrace.SERVER_PACKET_TRACE_MASK;
                    if (qp.getType() == Leader.PING) {
                        traceMask = ZooTrace.SERVER_PING_TRACE_MASK;
                    }
                    ZooTrace.logQuorumPacket(LOG, traceMask, 'i', qp);
                    tickOfLastAck = leader.self.tick;
    
    
                    ByteBuffer bb;
                    long sessionId;
                    int cxid;
                    int type;
    
                    switch (qp.getType()) {                                                 // 获取读入包的类型
                    case Leader.ACK:
                        leader.processAck(qp.getZxid(), sock.getLocalSocketAddress());      // 确认获取了ACK信息
                        break;
                    case Leader.PING:
                        // Process the touches
                        ByteArrayInputStream bis = new ByteArrayInputStream(qp
                                .getData());
                        DataInputStream dis = new DataInputStream(bis);                     // 处理ping类型消息
                        while (dis.available() > 0) {
                            long sess = dis.readLong();
                            int to = dis.readInt();
                            leader.zk.touch(sess, to);                                      // 获取sess值更新seesion
                        }
                        break;
                    case Leader.REVALIDATE:
                        bis = new ByteArrayInputStream(qp.getData());                       // 验证session是否存活
                        dis = new DataInputStream(bis);
                        long id = dis.readLong();
                        int to = dis.readInt();
                        ByteArrayOutputStream bos = new ByteArrayOutputStream();
                        DataOutputStream dos = new DataOutputStream(bos);
                        dos.writeLong(id);
                        boolean valid = leader.zk.touch(id, to);
                        ZooTrace.logTraceMessage(LOG,
                                                 ZooTrace.SESSION_TRACE_MASK,
                                                 "Session 0x" + Long.toHexString(id)
                                                 + " is valid: "+ valid);
                        dos.writeBoolean(valid);
                        qp.setData(bos.toByteArray());
                        queuedPackets.add(qp);
                        break;
                    case Leader.REQUEST:
                        bb = ByteBuffer.wrap(qp.getData());                                 // 处理请求
                        sessionId = bb.getLong();
                        cxid = bb.getInt();
                        type = bb.getInt();
                        bb = bb.slice();
                        if(type == OpCode.sync){
                         	leader.zk.submitRequest(new FollowerSyncRequest(this, sessionId, cxid, type, bb,
                                    qp.getAuthinfo()));                                     // 如果是同步则提交请求到同步请求
                        } else {
                        leader.zk.submitRequest(null, sessionId, type, cxid, bb,
                                qp.getAuthinfo());                                          // 否则直接提交数据去处理
                        }
                        break;
                    default:
                    }
                }
            } catch (IOException e) {
                if (sock != null && !sock.isClosed()) {
                    LOG.error("FIXMSG",e);
                }
            } catch (InterruptedException e) {
                LOG.error("FIXMSG",e);
            } finally {
                LOG.warn("******* GOODBYE " 
                        + (sock != null ? sock.getRemoteSocketAddress() : "<null>")         // 打印信息
                        + " ********");
                // Send the packet of death
                try {
                    queuedPackets.put(proposalOfDeath);                                     // 关闭发送的线程
                } catch (InterruptedException e) {
                    LOG.error("FIXMSG",e);
                }
                shutdown();                                                                 // 重置并移除在leader中的该handler
            }
        }
    
        public void shutdown() {
            try {
                if (sock != null && !sock.isClosed()) {                                     // 检查sock是否关闭 如果没关则关闭
                    sock.close();
                }
            } catch (IOException e) {
                LOG.error("FIXMSG",e);
            }
            leader.removeFollowerHandler(this);                                             // 移除该handler           
        }
    

    run函数主要就是先同步数据,检查获取从的包的事务ID如果ID不同则将当前主的数据同步发送给从,主要完成了数据同步的工作,在检查完成之后,就会启动一个单独的线程去发送数据给从,并且主会监听从发送过来的请求并将该请求处理。从这段执行流程也可知followe会转发客户端的请求到主上面来,全局只有主来处理客户端的数据请求。

        private void sendPackets() throws InterruptedException {
            long traceMask = ZooTrace.SERVER_PACKET_TRACE_MASK;
            while (true) {
                QuorumPacket p;
                p = queuedPackets.take();                                   // 获取队列中的数据
    
                if (p == proposalOfDeath) {                                 // 如果要停止则停止循环
                    // Packet of death!
                    break;
                }
                if (p.getType() == Leader.PING) {                           // 获取待发送消息类型
                    traceMask = ZooTrace.SERVER_PING_TRACE_MASK;
                }
                ZooTrace.logQuorumPacket(LOG, traceMask, 'o', p);
                try {
                    oa.writeRecord(p, "packet");                           // 发送该消息
                    bufferedOutput.flush();
                } catch (IOException e) {
                    if (!sock.isClosed()) {
                        LOG.warn("Unexpected exception",e);
                    }
                    break;
                }
            }
        }
    

    启动之后就又一个单独的线程专门监听发送队列并从该队列中取数据发送给从。至此,Leader角色的主要的流程基本执行完成。

    总结

    本文主要是分析了Leader角色的启动流程,主要就是先恢复重建本地的日志和事物数据,然后接受从的请求,并比较从的数据是否和主数据一致,如果不一致则从主中发送数据给从达到数据同步。然后再监听从的响应请求并处理,其中包括如果从接受的客户端的请求会转发给主处理,基本的处理流程就是这样。由于本人才疏学浅,如有错误请批评指正。

    展开全文
  • 基于重复角色和任务优先级的访问控制模型,姜增虎,陈茂华,针对一个角色可以对应多个不同的任务,以及任务重要的不同,在任务规则的基础上,提出了基于重复角色和任务优先级的访问控制模
  • 数据库中对应不同的用户拥有不同的角色,所以有不同的权限。 1.角色:打开企业管理器,在安全里面可以看到服务器角色,在单个的数据库中可以看到数据库角色。数据库角色范围比服务器角色小,数据库角色针对一个...

       数据库中对应不同的用户拥有不同的角色,所以有不同的权限。

    1.角色:

    打开企业管理器,在安全性里面可以看到服务器角色,在单个的数据库中可以看到数据库角色。数据库角色范围比服务器角色小,数据库角色针对一个数据库。服务器角色是安装SQL SERVER时内建的角色,不能删除,也不能增加角色。数据库角色是建立数据库时系统建立的,可以增加数据库角色,但不能删除系统自建的数据库。

    2.登录:在安全性里面可以看到登录,登录类型有三种:Windows组,Windows用户,标准;

    当新建登录时,身份验证:可以选择Windows身份验证,也可以选择sql server身份验证(需要输入密码)。

    如果选择Windows身份验证,则新建的登录类型为windows用户,如果选择sql server身份验证则新建的登录类型为标准。

    新建一个登录之后可以选择服务器角色和可访问的数据库,对于选中的数据库,在用户那里会出现一个对应于登录的用户。

    3.用户:对应于每个数据库都有用户,可以修改用户的数据库角色,也可以点击权限来修改用户可以做的操作。

    其次:在安装数据库的过程中就创建了一个系统管理员登录(sa),对应于每个数据库有一个超级用户dbo.

    展开全文
  • 但是因为我的玩法弹性很大…所以在写了这篇文章之后我可能会再相对应地转变一下自己的玩法,哈哈 题外话太多了,进入正题)。 以后还有时间的话会再写一篇《抿身份篇》和《特殊角色介绍及玩法篇略解》(特殊角色包括...
  • Oracle中的角色权限和对象权限简介

    千次阅读 2010-04-09 18:02:00
    Oracle中的系统权限类型非常多,使用起来有一定的困难,为了简化对权限的管理,Oracle中提供了角色的概念,一个角色对应了一组系统操作(即系统权限),大家可以从OEM中“安全->角色”中可以看到每个角色具体包含...
  • CIO的角色定位

    2012-12-04 19:28:23
    CIO是与公司中其他的最高层管理人,如首席财务官(CFO)、首席运营官(COO),这一类职务相对应的职务,这些CXO们协助首席行政官(CEO)的工作,并与CEO一起向董事会负责。在有些国家(如美国)的政府机构内或非商业机构也...
  • 1、业务需求,导入业务部分2、用户直接接触的,用户体验部分3、产品开发实施,技术部分4、市场推广营收,经营部分任何一个产品都深深依托行业发展的背景中,对行业的认知程度,前瞻都决定产品的命运。控制团队协作...
  • 而且不能支持宽度超过32的角色。3.x 将把event层、event2层与hero层合并用sprite实现,bg和fg暂时不变。 <h2>1. sprite对象 <p>sprite对象类(spriteObj)包含贴图的所有实际绘制数据(原图...
  • Forms身份验证基于角色的授权一 身份验证在web.config的的设置还是一样: /login.aspx验证用户合法页面中,在验证了用户的合法后,还要有个取得此用户属于哪些role的过程,这个看各个应用的本身如何设计的了,...
  • 一台正常的Exchange2010 CAS角色的IIS里,应该如下图所示包含一些功能的虚拟目录。其中需要注意的,是它们的.NetFrameWork版本,与所属的AppPool那么如果需要对Exchange2010进行二次开发,在特定的需求下,需要...
  • 每一个SQL Server的数据库都会按照其修改数据(insert,update,delete)的顺序将对应的日志记录到日志文件.SQL Server使用了Write-Ahead logging技术来保证了事务日志的原子和持久.而这项技术不仅仅保证了ACID中的...
  •  每一个SQL Server的数据库都会按照其修改数据(insert,update,delete)的顺序将对应的日志记录到日志文件.SQL Server使用了Write-Ahead logging技术来保证了事务日志的原子和持久.而这项技术不仅仅保证了ACID中...
  • (在MySQL Server 5.0 下载与 安装指南[图文] (安装到非系统路径+设置root账号对应密码) 这个文章里面的mysql下载包,一起放的工具就有SQLyog) ...................................................
  • 基于授权和角色的访问控制的设计和实现(二) (转)[@more@]二 分析设计 ...由于安全对象在程序设计期确定,所以设计的目标是确保一个需要控制的地方有且仅有一个安全对象(一一对应),至于维护之...
  • 同一个类目也经常会做不同的产品,对应商品的形态和功能都不太一样。到综商品系统为了满足不同类目个性化的商品需求、同时保证接入的高效,我们搭建了商品配置中心,在不同层次大量采用了配置化的技术去解决这些问题...
  • 对应的数据库下查看是否有对应的用户,若有将其删除 然后在数据库服务器的安全,登录名中去重新配映射。
  •  每一个SQL Server的数据库都会按照其修改数据(insert,update,delete)的顺序将对应的日志记录到日志文件.SQL Server使用了Write-Ahead logging技术来保证了事务日志的原子和持久.而这项技术不仅仅保证了ACID中...
  • Angular 依赖注入

    2017-10-03 19:21:51
    依赖注入其实是一种设计模式,对应的还会有依赖注入的框架,对于复杂的项目来说需要一个相对工程化的框架来帮我们处理这些事情,而angular就提供了一个比较完整的依赖注入框架 这个框架当中有几个主要角色...
  • 每一个SQL Server的数据库都会按照其修改数据(insert,update,delete)的顺序将对应的日志记录到日志文件.SQL Server使用了Write-Ahead logging技术来保证了事务日志的原子和持久.而这项技术不仅仅保证了ACID中的...
  • 西门子距离推出S7-300/S7-400系列已经很多年,这些年里西门子一直不断的寻找升级的可能,其中PCS7就是一个升级失败的产品,期间西门子强力推广西门子博途系列即S1200和S1500,并最终获得成功,其中S1200对应的是S7...
  • Struts2安全学习笔记

    2016-08-23 19:02:50
    在tomcat中的conf文件中的tomcat-users.xml中添加角色,以及与角色对应的用户及密码: 上面的这些角色例如"manager"可以通过部署描述文件来访问指定资源。元素security-constraint来保护相应资源,其...
  • 1、用户安全域:每个用户都有一个对应的安全域(security domain),所谓安全域实际上是一组属性,这组属性决定了: 用户可执行的操作(权限(privilege)或角色(role))用户的表空间限额(tablespace quota)...
  • 13 实现安全

    2010-02-28 09:01:00
    本章所讨论的安全包括ms windows...第一层称为基于角色的安全,该层控制用户对应应用程序资源和操作的访问;第二层CAS,该层不仅控制代码对资源的访问,还控制代码执行特权操作的权限。 1.1 身份验证 身份...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 601
精华内容 240
关键字:

对应性角色