精华内容
下载资源
问答
  • 一般公司都是等级分明的,上级下级的定位很清楚, 谁是上级, 谁是他的下级或下属, 谁管理谁。这里的管理, 不仅仅是 管理层, 技术部门也是有管理者的。 有的人权高位重,年老经丰。( 当然,是否德高望重就不...

    管理是一门很深的学问。

    一般公司都是等级分明的,上级与下级的定位很清楚, 谁是上级, 谁是他的下级或下属, 谁管理谁。这里的管理, 不仅仅是 管理层, 技术部门也是有管理者的。 有的人权高位重,年老经丰。( 当然,是否德高望重就不清楚了。) , 自然, 他是管理者, 他有权去要求去命令去分配任务给一下新人。 他们有权威, 有尊严, 需要对他们毕恭毕敬。

    上级一般不会主动和下级讨论的, 他们可能觉得这样有失颜面。 他们只会发布要求和命令。

    下级则经常会有需要和上级讨论的, 讨论技术, 或者业务需求, 或者某些细节, 但是, 如果 上级总是一副自己牛逼哄哄的高高在上的嘴脸, 让人感觉不容易亲近, 那么这样的讨论会大打折扣。 讨论会减少,次数和时间都会减少。 而且会仅限于 必须的讨论, 那些什么技术提升的讨论, 个人想法的 讨论, 则会埋于心底。 久而久之, 氛围变得几乎没人讨论, 氛围死气沉沉。。。

    有人说这个是 某些人的自私, 不愿意分享, 高手不愿给新生交流传授经验。 —— 我认为这不单单是这个原因, 每个人都是自私的, 没人真正原因没有任何的一点点的好处去给你分享。 特别是我给你分享了,你没有感激我, 你也不会给我任何的好处, (仅仅是 口头上的谢谢, 显然是不足以让人去诚心分享的) , 公司层面也没有给我任何的奖励。 那么高手也是不会有这样的动力的! —— 即使管理层给我们开会说明了, 要各位员工们, 好好的相互合作, 分享。 这个也是 推不动。

    有关人性的学问, 都是复杂的学问, 因为人性的多面性,复杂性, 多变性。世事无常, 事态复杂, 瞬息万变。 这些都会影响到人们的行为。

    一个团队是否能够紧密的合作, 高效的运转, 很大程度在于领导者的组织协调能力, 他对人性的理解, 他对形势的解读,事态把握能力。 商业的合作本质上都是 谋求利益, 不一定要均分利益, 但是一定要让每个人都有利可图, 让他们都觉得合理, 可接受。 公司成员间也是一样。

    如果公司文化不对, 很大可能会发展长上面的那样。 但是, 只要一个公司有真正的文化, 那么则会大有不同。

    处于好的公司文化, 员工们,上下级等级之间没有明显的 界限, 没有各种各样的 命令, 有的只是 相互的探讨, 交流,相互关心, 有福同享有难同当, 他们关系很融洽。 每个人知道自己的职责, 愿意担当这个职责。 知道自己的能力, 知道自己能够做什么, 怎么做。 这样才能高效的工作!

    这就是文化的力量!

    posted on 2017-01-11 12:38 CanntBelieve 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/FlyAway2013/p/6273158.html

    展开全文
  • 人力资源在一个树型结构当中,存在下属员工进行操作,如修改员工的信息等.员工表字段 EmployeeId PerantId LoginName Name ...例如 A ——————————————————————1 A_1 ——————————...

    人力资源

    在一个树型结构当中,存在对下属员工进行操作,如修改员工的信息等.

    员工表字段 EmployeeId PerantId LoginName Name ...

    例如
    A  ——————————————————————1
       A_1  ————————————————————2
       A_2
       A_3
                A_3_1 —————————————————3
                A_3_2
                A_3_3
                A_3_4
       A_4(B)
                A_4_1(C)
                          A_4_1_1( D)   ———————————4
                                         A_4_1_1_1(E) ———————5
                A_4_2
                A_4_3
                A_4_4
    。。。。

    现在 A 有权力下面所有人进行修查看操作。

    而 A_4 的权限只能查看,他下面员工的信息,不能查看A_3、A_2、A_1 的信息及他们各自的下属的信息。

    现在 B  员工要对 E 员工进行修改,可是数据库里又没对 B 员工修改下面员工 E 的权限。

    如果对 B 进行权限设置,他就得对它下面所有每个员工进行权限分配,这样的话权限表就会非常大了。

    最底一层(N)就可以有N-1个人有对他修改的权限,这样不好。

    如果要 E 的内容可以由 D、C、B、A 这些人才可以修改,其他人就不行了

    要实现 B 有没有对 E 员工进行修改的权限,由两种法子(我认为)

    第一就是通过算法,把 B 下属员工全部取出来,然后看 E  在没有在里头。

    第二就是通过算法,我把有修改 E 用户信息的员工取一个,跟 B 进行比较是不是到了

    如果没有再从 E 的上级的上级取出来跟 B 进行比较,依此类推如果没有 B  的话,它最多取 N-1 次结束。

    我个人认为第二种要比第一种好得好。

    下面我就把实现第二种的代码如下


    private static string connectionString = ConfigurationManager.ConnectionStrings["WaterOfficeConnectionString"].ToString();
    private static SqlConnection getSqlConnection()
    {
        SqlConnection cn 
    = new SqlConnection();
        cn.ConnectionString 
    = connectionString;
        cn.Open();
        
    return cn;
    }

    private static SqlCommand getSqlCommand()
    {
        SqlConnection cn 
    = getSqlConnection();
        SqlCommand cmd 
    = new SqlCommand();
        cmd.Connection 
    = cn;
        
    return cmd;
    }
     
    private static object ExecuteScalar(string executeString)
    {
        
    object obj = null;
        SqlCommand cmd 
    = getSqlCommand();
        
    try
        
    {
            cmd.CommandText 
    = executeString;
            obj 
    = cmd.ExecuteScalar();
        }

        
    finally
        
    {
            cmd.Connection.Close();
        }

        
    return obj;
    }

    private int employeeID(string userName)
    {
        
    string sqlString = "select EmployeeId from employee where LoginName  = '" + userName + "'";
        
    int  userNameId = int.Parse(ExecuteScalar(sqlString).ToString());
        
    return userNameId;
    }

    private static int _pId;
    /// <summary>
    /// 员工上一级的ID号
    /// </summary>

    private static int pId
    {
        
    get return _pId; }
    }

    /// <summary>
    /// 员工上一级的ID号
    /// </summary>
    /// <param name="pid"></param>
    /// <returns></returns>

    private static int ParentID(int pid)
    {
        
    int parentId;
        
    string sqlString = "select ParentId,isDel from employee where EmployeeID = " + pid;
        SqlCommand cmd 
    = getSqlCommand();
        cmd.CommandText 
    = sqlString ;
        SqlDataReader sdr 
    = cmd.ExecuteReader();
        
    if (!sdr.Read())
        
    {
            
    return -404;
        }

        parentId 
    = sdr.GetInt32(0);
        _isDel 
    = sdr.GetBoolean(1);
        
    if (parentId == 0 || _isDel == false)
        
    {
            _pId 
    = parentId;
        }

        sdr.Close();
        cmd.Connection.Close();
        
    return parentId;
    }

    /// <summary>
    /// 判断是不是相同,如果员工的上级ID与此管理员ID相同就为 true 
    /// </summary>
    /// <param name="number1">管理员ID</param>
    /// <param name="number2">上一级的ID</param>
    /// <returns></returns>

    private bool isExist(int number1, int number2)
    {   
        
    if (number1 == number2)
        
    {
            
    return true;
        }

        
    else
        
    {
            
    return false;
        }

    }


    /// <summary>
    /// 看看是不是这个员工的上级员工ID号
    /// </summary>
    /// <returns></returns>

    private bool isEmployeeParentId()
    {
        
    int userId1 = employeeID("userName1") ;
        
    int userId2 = employeeID("userName2");
        
    int parId = ParentID(userId1);
        
    bool temp = true;
        
    while (!isExist(userId2, parId))
        
    {
            
    if (pId == 0 || parId == -404)
            
    {
                temp 
    = false;
                
    break;
        }

        parId 
    = ParentID(parId);
        }

        
    return  temp;
    }


    我只想到这种法子,第一种的实现我觉得好难,写不出来。

    我想一定还会有再好的算法。

    展开全文
  • 答案是能!...首先根据 roleName 从 rolesReachableInOneStepMap 中获取对应的 rolesToVisitSet,这个 rolesToVisitSet 是一个 Set 集合,其进行遍历,将遍历结果添加到 visitedRolesSet 集合中,如果 ...

    答案是能!

    松哥之前写过类似的文章,但是主要是讲了用法,今天我们来看看原理!

    本文基于当前 Spring Security 5.3.4 来分析,为什么要强调最新版呢?因为在在 5.0.11 版中,角色继承配置和现在不一样。旧版的方案我们现在不讨论了,直接来看当前最新版是怎么处理的。

    1.角色继承案例

    我们先来一个简单的权限案例。

    创建一个 Spring Boot 项目,添加 Spring Security 依赖,并创建两个测试用户,如下:

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("javaboy")
                .password("{noop}123").roles("admin")
                .and()
                .withUser("江南一点雨")
                .password("{noop}123")
                .roles("user");
    }
    

    然后准备三个测试接口,如下:

    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello() {
            return "hello";
        }
    
        @GetMapping("/admin/hello")
        public String admin() {
            return "admin";
        }
    
        @GetMapping("/user/hello")
        public String user() {
            return "user";
        }
    }
    

    这三个测试接口,我们的规划是这样的:

    1. /hello 是任何人都可以访问的接口
    2. /admin/hello 是具有 admin 身份的人才能访问的接口
    3. /user/hello 是具有 user 身份的人才能访问的接口
    4. 所有 user 能够访问的资源,admin 都能够访问

    注意第四条规范意味着所有具备 admin 身份的人自动具备 user 身份。

    接下来我们来配置权限的拦截规则,在 Spring Security 的 configure(HttpSecurity http) 方法中,代码如下:

    http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("admin")
            .antMatchers("/user/**").hasRole("user")
            .anyRequest().authenticated()
            .and()
            ...
            ...
    

    这里的匹配规则我们采用了 Ant 风格的路径匹配符,Ant 风格的路径匹配符在 Spring 家族中使用非常广泛,它的匹配规则也非常简单:

    通配符 含义
    ** 匹配多层路径
    * 匹配一层路径
    ? 匹配任意单个字符

    上面配置的含义是:

    1. 如果请求路径满足 /admin/** 格式,则用户需要具备 admin 角色。
    2. 如果请求路径满足 /user/** 格式,则用户需要具备 user 角色。
    3. 剩余的其他格式的请求路径,只需要认证(登录)后就可以访问。

    注意代码中配置的三条规则的顺序非常重要,和 Shiro 类似,Spring Security 在匹配的时候也是按照从上往下的顺序来匹配,一旦匹配到了就不继续匹配了,所以拦截规则的顺序不能写错

    如果使用角色继承,这个功能很好实现,我们只需要在 SecurityConfig 中添加如下代码来配置角色继承关系即可:

    @Bean
    RoleHierarchy roleHierarchy() {
        RoleHierarchyImpl hierarchy = new RoleHierarchyImpl();
        hierarchy.setHierarchy("ROLE_admin > ROLE_user");
        return hierarchy;
    }
    

    注意,在配置时,需要给角色手动加上 ROLE_ 前缀。上面的配置表示 ROLE_admin 自动具备 ROLE_user 的权限。

    接下来,我们启动项目进行测试。

    项目启动成功后,我们首先以 江南一点雨的身份进行登录:

    登录成功后,分别访问 /hello/admin/hello 以及 /user/hello 三个接口,其中:

    1. /hello 因为登录后就可以访问,这个接口访问成功。
    2. /admin/hello 需要 admin 身份,所以访问失败。
    3. /user/hello 需要 user 身份,所以访问成功。

    再以 javaboy 身份登录,登录成功后,我们发现 javaboy 也能访问 /user/hello 这个接口了,说明我们的角色继承配置没问题!

    2.原理分析

    这里配置的核心在于我们提供了一个 RoleHierarchy 实例,所以我们的分析就从该类入手。

    RoleHierarchy 是一个接口,该接口中只有一个方法:

    public interface RoleHierarchy {
    	Collection<? extends GrantedAuthority> getReachableGrantedAuthorities(
    			Collection<? extends GrantedAuthority> authorities);
    
    }
    

    这个方法参数 authorities 是一个权限集合,从方法名上看方法的返回值是一个可访问的权限集合。

    举个简单的例子,假设角色层次结构是 ROLE_A > ROLE_B > ROLE_C,现在直接给用户分配的权限是 ROLE_A,但实际上用户拥有的权限有 ROLE_AROLE_B 以及 ROLE_C

    getReachableGrantedAuthorities 方法的目的就是是根据角色层次定义,将用户真正可以触达的角色解析出来。

    RoleHierarchy 接口有两个实现类,如下图:

    • NullRoleHierarchy 这是一个空的实现,将传入的参数原封不动返回。
    • RoleHierarchyImpl 这是我们上文所使用的实现,这个会完成一些解析操作。

    我们来重点看下 RoleHierarchyImpl 类。

    这个类中实际上就四个方法 setHierarchygetReachableGrantedAuthoritiesbuildRolesReachableInOneStepMap 以及 buildRolesReachableInOneOrMoreStepsMap,我们来逐个进行分析。

    首先是我们一开始调用的 setHierarchy 方法,这个方法用来设置角色层级关系:

    public void setHierarchy(String roleHierarchyStringRepresentation) {
    	this.roleHierarchyStringRepresentation = roleHierarchyStringRepresentation;
    	if (logger.isDebugEnabled()) {
    		logger.debug("setHierarchy() - The following role hierarchy was set: "
    				+ roleHierarchyStringRepresentation);
    	}
    	buildRolesReachableInOneStepMap();
    	buildRolesReachableInOneOrMoreStepsMap();
    }
    

    用户传入的字符串变量设置给 roleHierarchyStringRepresentation 属性,然后通过 buildRolesReachableInOneStepMap 和 buildRolesReachableInOneOrMoreStepsMap 方法完成对角色层级的解析。

    buildRolesReachableInOneStepMap 方法用来将角色关系解析成一层一层的形式。我们来看下它的源码:

    private void buildRolesReachableInOneStepMap() {
    	this.rolesReachableInOneStepMap = new HashMap<>();
    	for (String line : this.roleHierarchyStringRepresentation.split("\n")) {
    		String[] roles = line.trim().split("\\s+>\\s+");
    		for (int i = 1; i < roles.length; i++) {
    			String higherRole = roles[i - 1];
    			GrantedAuthority lowerRole = new SimpleGrantedAuthority(roles[i]);
    			Set<GrantedAuthority> rolesReachableInOneStepSet;
    			if (!this.rolesReachableInOneStepMap.containsKey(higherRole)) {
    				rolesReachableInOneStepSet = new HashSet<>();
    				this.rolesReachableInOneStepMap.put(higherRole, rolesReachableInOneStepSet);
    			} else {
    				rolesReachableInOneStepSet = this.rolesReachableInOneStepMap.get(higherRole);
    			}
    			rolesReachableInOneStepSet.add(lowerRole);
    		}
    	}
    }
    

    首先大家看到,按照换行符来解析用户配置的多个角色层级,这是什么意思呢?

    我们前面案例中只是配置了 ROLE_admin > ROLE_user,如果你需要配置多个继承关系,怎么配置呢?多个继承关系用 \n 隔开即可,如下 ROLE_A > ROLE_B \n ROLE_C > ROLE_D。还有一种情况,如果角色层级关系是连续的,也可以这样配置 ROLE_A > ROLE_B > ROLE_C > ROLE_D

    所以这里先用 \n 将多层继承关系拆分开形成一个数组,然后对数组进行遍历。

    在具体遍历中,通过 > 将角色关系拆分成一个数组,然后对数组进行解析,高一级的角色作为 key,低一级的角色作为 value。

    代码比较简单,最终的解析出来存入 rolesReachableInOneStepMap 中的层级关系是这样的:

    假设角色继承关系是 ROLE_A > ROLE_B \n ROLE_C > ROLE_D \n ROLE_C > ROLE_E,Map 中的数据是这样:

    • A–>B
    • C–>[D,E]

    假设角色继承关系是 ROLE_A > ROLE_B > ROLE_C > ROLE_D,Map 中的数据是这样:

    • A–>B
    • B–>C
    • C–>D

    这是 buildRolesReachableInOneStepMap 方法解析出来的 rolesReachableInOneStepMap 集合。

    接下来的 buildRolesReachableInOneOrMoreStepsMap 方法则是对 rolesReachableInOneStepMap 集合进行再次解析,将角色的继承关系拉平。

    例如 rolesReachableInOneStepMap 中保存的角色继承关系如下:

    • A–>B
    • B–>C
    • C–>D

    经过 buildRolesReachableInOneOrMoreStepsMap 方法解析之后,新的 Map 中保存的数据如下:

    • A–>[B、C、D]
    • B–>[C、D]
    • C–>D

    这样解析完成后,每一个角色可以触达到的角色就一目了然了。

    我们来看下 buildRolesReachableInOneOrMoreStepsMap 方法的实现逻辑:

    private void buildRolesReachableInOneOrMoreStepsMap() {
    	this.rolesReachableInOneOrMoreStepsMap = new HashMap<>();
    	for (String roleName : this.rolesReachableInOneStepMap.keySet()) {
    		Set<GrantedAuthority> rolesToVisitSet = new HashSet<>(this.rolesReachableInOneStepMap.get(roleName));
    		Set<GrantedAuthority> visitedRolesSet = new HashSet<>();
    		while (!rolesToVisitSet.isEmpty()) {
    			GrantedAuthority lowerRole = rolesToVisitSet.iterator().next();
    			rolesToVisitSet.remove(lowerRole);
    			if (!visitedRolesSet.add(lowerRole) ||
    					!this.rolesReachableInOneStepMap.containsKey(lowerRole.getAuthority())) {
    				continue;
    			} else if (roleName.equals(lowerRole.getAuthority())) {
    				throw new CycleInRoleHierarchyException();
    			}
    			rolesToVisitSet.addAll(this.rolesReachableInOneStepMap.get(lowerRole.getAuthority()));
    		}
    		this.rolesReachableInOneOrMoreStepsMap.put(roleName, visitedRolesSet);
    	}
    }
    

    这个方法还比较巧妙。首先根据 roleName 从 rolesReachableInOneStepMap 中获取对应的 rolesToVisitSet,这个 rolesToVisitSet 是一个 Set 集合,对其进行遍历,将遍历结果添加到 visitedRolesSet 集合中,如果 rolesReachableInOneStepMap 集合的 key 不包含当前读取出来的 lowerRole,说明这个 lowerRole 就是整个角色体系中的最底层,直接 continue。否则就把 lowerRole 在 rolesReachableInOneStepMap 中对应的 value 拿出来继续遍历。

    最后将遍历结果存入 rolesReachableInOneOrMoreStepsMap 集合中即可。

    这个方法有点绕,小伙伴们可以自己打个断点品一下。

    看了上面的分析,小伙伴们可能发现了,其实角色继承,最终还是拉平了去对比。

    我们定义的角色有层级,但是代码中又将这种层级拉平了,方便后续的比对。

    最后还有一个 getReachableGrantedAuthorities 方法,根据传入的角色分析出其可能潜在包含的一些角色:

    public Collection<GrantedAuthority> getReachableGrantedAuthorities(
    		Collection<? extends GrantedAuthority> authorities) {
    	if (authorities == null || authorities.isEmpty()) {
    		return AuthorityUtils.NO_AUTHORITIES;
    	}
    	Set<GrantedAuthority> reachableRoles = new HashSet<>();
    	Set<String> processedNames = new HashSet<>();
    	for (GrantedAuthority authority : authorities) {
    		if (authority.getAuthority() == null) {
    			reachableRoles.add(authority);
    			continue;
    		}
    		if (!processedNames.add(authority.getAuthority())) {
    			continue;
    		}
    		reachableRoles.add(authority);
    		Set<GrantedAuthority> lowerRoles = this.rolesReachableInOneOrMoreStepsMap.get(authority.getAuthority());
    		if (lowerRoles == null) {
    			continue;
    		}
    		for (GrantedAuthority role : lowerRoles) {
    			if (processedNames.add(role.getAuthority())) {
    				reachableRoles.add(role);
    			}
    		}
    	}
    	List<GrantedAuthority> reachableRoleList = new ArrayList<>(reachableRoles.size());
    	reachableRoleList.addAll(reachableRoles);
    	return reachableRoleList;
    }
    

    这个方法的逻辑比较直白,就是从 rolesReachableInOneOrMoreStepsMap 集合中查询出当前角色真正可访问的角色信息。

    3.RoleHierarchyVoter

    getReachableGrantedAuthorities 方法将在 RoleHierarchyVoter 投票器中被调用。

    public class RoleHierarchyVoter extends RoleVoter {
    	private RoleHierarchy roleHierarchy = null;
    	public RoleHierarchyVoter(RoleHierarchy roleHierarchy) {
    		Assert.notNull(roleHierarchy, "RoleHierarchy must not be null");
    		this.roleHierarchy = roleHierarchy;
    	}
    	@Override
    	Collection<? extends GrantedAuthority> extractAuthorities(
    			Authentication authentication) {
    		return roleHierarchy.getReachableGrantedAuthorities(authentication
    				.getAuthorities());
    	}
    }
    

    关于 Spring Security 投票器,将是另外一个故事,松哥将在下篇文章中和小伙伴们分享投票器和决策器~

    4.小结

    好啦,今天就和小伙伴们简简单单聊一下角色继承的问题,感兴趣的小伙伴可以自己试一下~如果觉得有收获,记得点个在看鼓励下松哥哦~

    展开全文
  • 上级下级交互感悟

    2011-04-22 15:01:00
    最近在某网络公司实习,公司的节奏感有深刻的感触。。记录于此,从此改变。。 刚来公司时候,有人带我或者是自己有一个上司,负责直接管理你。   1 平时安排任务的时候   在上司...

    最近在某网络公司实习,对公司的节奏感有深刻的感触。。记录于此,从此改变。。

    刚来公司时候,有人带我或者是自己有一个上司,负责直接管理你。

     

    1 平时安排任务的时候

     

    在上司给你安排任务的时候,细致的问一下任务要做到什么程度。

     

    要问的问题:这个任务希望做成什么样子,这个任务的时间限制,做的这个任务目的是什么等等。

     

    A

    其实大多数时候,上司当时也并没有想好该把任务做成什么样子。

    刚开始的时候,大体设想了一个样子,就觉得任务做完了,等着上司来找我要任务,可是上司大多数时间也很忙,也许就一时忘了给你的任务了,等他哪天想起来这个任务的时候,他找到你要看一下你停了好久的任务,当时我停下来就做别的事情了,我以为我把任务做完了,结果上司很不高兴,觉得做的不够。

     

    B

    正确的做法应该是这个样子的,当然在做任务的时候,在问清楚任务的"当前情况 "之后,就着手去做这个任务,当然要把大问题分解成小问题(不会分解的话,自己花时间去学),然后安排好时间,各个击破,在自己觉得基本完成任务 之后,要及时和boss,还有大boss沟通(当然要搞清楚哪个是真正的boss),让他们验收你的任务,这不仅是验收也是一个检查的过程,他们会指出哪些不足,然后就又有问题了,那么再去补充解决,解决完了再找boss验收,这是一个循环往复的过程!

     

    2 在写日报和周报的时候

     

    boss安排完任务之后,就会去忙别的事情了,他对你如何做完这个任务的,在做这个任务的时候经历了哪些过程,都不知晓。因此周报,日报是一个向你头顶上的各种大boss,小boss们汇报你所做的事情的。

     

    就把他当成一个当面详细的给你的boss介绍今天所做的事的途径。

     

    日报写法:

     

    1 今天各个时间段

     

    1.1 各做了什么事情(一定要明细,让读日报的人了解的清楚 ),

    1.2 解决了工作中的哪些问题(问题一定要好好描述 ),

    1.3 做这件事情的原因是什么(这是问题的背景需要让读的人好好了解 ),

    1.4 最后解决了没有(这是这段时间做的效果 ),

    1.5 感受,效率如何(这段是体现你这段时间通过这件事情或这个问题学到了什么 )。

     

    2 总结一下整个时间段遇到的问题,这个问题也要好好描述的很细致,让boss能够了解你的问题在哪,这是跟boss交流心得的很好方式,boss看到了也许会给予解答。

     

    周报写法:

     

    1 从boss安排任务的维度细致的写一下 各个任务完成的情况,遇到的问题。(并不是先写完工作内容才写问题的,而是在考虑这周所做的每个工作任务的时候,将每个任务遇到的大问题,小问题都写入遇到的问题 中。)

     

    2 将每天日报的东西,总结到周报中,向各种大boss上报。一定要站在他们boss读者的角度去说清楚,即使自己理不清楚也要理清楚了再往上写。

     

     

    周报日报是一个宣传的过程,各种事情,自己做了一定要学会宣传,即使做不好宣传做得好也行。并且周报日报是一个交流并提高的过程。

    一定要重视起来!!!

     

     

     

     

     

     

    展开全文
  • 正如我在《相互信任是上下级相处的前提》文章中所说的,相互信任比什么都... 那么上级如何获得下级的信任呢? 1.为下级的发展考虑;考虑的目标就是专业化发展,能够跟进下属的兴趣,结合岗位的职责,提出远期的发展...
  • 上级可以查看下级数据,是递归的问题,也是程序里需要通过SQL语句的 例如,你都能看的部门的ID数组计算出来,然后你的部门IN (ID数组)的,你可以查看的思路。 客户 9:32:15 那你的权限里面也是通过这种方式吗? ...
  • 如何表示上级目录../表示源文件所在目录的上一级目录,../../表示源文件所在目录的上上级目录,以此类推。假设info.html路径是:c:Inetpubwwwrootsitesblablainfo.html假设index.html路径是:c:...
  • 下级不能比上级工资高吗?

    千次阅读 2017-03-03 18:42:37
    下级可以比上级工资高
  • 这段时间在和同事们面谈,目的了解下同事们的情况,解答些疑问,听一些他们团队公司的建议等等,这种面对面、一一的面谈,会收到很好的效果。如果你也是一名管理者,那么你如何组织这次面谈,以达...
  • 前面的文章《相互信任是上下级相处的前提》谈到相互信任比什么都...同时在文章《 那么上级如何获得下级的信任》中说了如何获得下级的信任。 那么下级如何获得上级的信任,组织的信任呢? 1.做好自己的本职工作; ...
  • 我问的跟百度地址一样,不过他们那里没人知道解答,看这里的大神知不知道怎么设置,麻烦详细一点: ... 示例图: ... 问题就是:如何让.1.2(上层)的电脑访问...不要说把路由器换成交换机,那就没有做行为管理的功能了。
  • 今天在创建文件夹的时候出现了创建的下级文件夹和上级文件夹并列,紧凑排列的情况,这里在最新版本的vs code中解决的途径如下: 解决办法如下: 1 )点击上方文件,之后选择首选项,再进入设置; 2)在用户中选择...
  • 任何一个组织都存在上下级关系,在大家心中,上级管下属天经地义。所以这篇文章的标题《怎样管理你的上级领导》,有点很稀奇,甚至有点匪夷所思。 那为什么还要管理上级呢? 很多粉丝都问过我,“袁总,我已经工作5...
  • * 子部门的名称前比上级部门多一个空格,最顶层部门的名字前没有空格。 提示:假设有一个打印部门集合中所有部门信息的方法 * * 要求打印如下效果: * * * ┣市场部 * ┣宣传部 * ┣业务部 * ┣业务一部 * ┣业务二...
  • 海康威视iVMS-8700综合安防管理平台(以下简称iVMS-8700平台)是一套“集成化”、“数字化”、“智能化”的平台,包含视频、报警、门禁、访客、梯控、巡查、考勤、消费、停车场、可视对讲等多个子系统。在一个平台下...
  • ​任何一个组织都存在上下级关系,在大家心中,上级管下属天经地义。所以这篇文章的标题《怎样管理你的上级领导》,有点很稀奇,甚至有点匪夷所思。 那为什么还要管理上级呢? 很多粉丝都问过我,“袁总,我已经工作...
  • 任何一个组织都存在上下级关系,在大家心中,上级管下属天经地义。所以这篇文章的标题《怎样管理你的上级领导》,有点很稀奇,甚至有点匪夷所思。 那为什么还要管理上级呢? 很多粉丝都问过我,“袁总,我已经工作5...
  • 本系统只提供后台管理,前台您可以根据/article.asp文件进行相应修改
  • 职业素养:如何管理好你的上级 2013-10-31 本周领导叫去谈话的时候说到了上级管理。自己感觉先前这个...上级的工作方式、工作习惯都会直接影响你的工作方式和工作习惯,若不学会管理上级则经常会出现摩擦和碰...
  • 浅析企业上下级沟通的障碍及对策

    千次阅读 2019-04-25 11:06:37
    在企业的管理活动中,管理沟通起着至关重要的作用。上下级的有效沟通有利于企业的科学决策与目标的实现。本文通过组织内部沟通的研究,着重指出了上下级沟通的重要性。通过这一沟通的表述,指出了公司内部上下级...
  • 总体上是由各个单位建设平台,通过公网或专网将各地监控资源接入,这种监控设备接到平台的协议,我们一般指的就是国标GB/T28181。在TSINGSEE青犀视频云边端产品中,支持GB28181协议的视频平台时EasyGBS视频智能...
  • 如:权限管理的Resource资源,有上下级关联关系的映射 Hibernate实体类书写(toString 方法不要加入两个关联关系的映射) import java.util.List; import javax.persistence.CascadeType; import javax....
  • 领导的七种管理方式

    2010-01-28 20:27:00
    领导的七种管理方式 一、分权管理 分权就是转交责任,一个上级不是什么决策都自己作,而是将确定的工作委托给他的下级,让他们有一定的判断和独立处理工作的范围,同时也承担一部分责任。 下级因为参与责任提高了...
  • 例如,有些企业,某些人的上级不止一个,属于多领导,虽然有些口头上的分工,但分工并没有非常明确,还有的时候,一个人可能会有兼职,如某车间主任兼职工会主席,他就属于两个不同的管理条线下,还有些企业,排名...
  • 首先需要知道GB28181 上、下级关系,比如两个平台A和B,如B需要从A获取视频流,则B是上级平台,A是下级平台。 另外需要清楚国标下级平台是广义的,复杂的视频平台可以是国标下级平台,支持国标NVR可以称为国标平台...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,915
精华内容 4,366
关键字:

上级对下级的管理方式