精华内容
下载资源
问答
  • 《数据结构课程设计案例精编(用C/C++描述)》

    千次下载 热门讨论 2008-10-08 10:33:11
    附:《数据结构课程设计案例精编(用C/C++描述)》一书简介 本书是数据结构案例教程,以软件重用为指导思想,以STL库中实现的数据结构(容器)为参照,重构了数据结构的视角和知识体系,并突出实战性和应用性。. 本书...
  • 初期方案 设计初期,我们希望能够挖掘一些用户在手机端常用的点进行延伸,如:访客、礼物、动态。包括配色和图形设计也延伸了手机端的设计风格。...1.手表的尺寸较小,展示内容有所局限,并不适合长时间查看。

    初期方案

    设计初期,我们希望能够挖掘一些用户在手机端常用的点进行延伸,如:访客、礼物、动态。包括配色和图形设计也延伸了手机端的设计风格。

    pic_002.png

    竞品分析

    我们对Instagram和Twitter进行了研究,整体上是手机端的简化版,设计风格并无太多的亮点。

    pic_003.png

    基于上述分析,我们得出如下结论:

    1.手表的尺寸较小,展示内容有所局限,并不适合长时间查看。

    2.繁杂的内容不适合在手表上阅读,手表更多的是作为一种提醒的作用。

    3. 手表上的操作必须足够简单并且快速。

    pic_004.png

    空间用户的使用场景

    1.小白打开QQ空间Apple Watch版查看一天的好友动态,给好友们点赞和回复大表情,并且可以收到特别关心好友的动态提醒。

    pic_005.png

    2. 小白每天在手表上使用QQ空间AppleWatch版进行签到。

    pic_006.gif

    通过分析手表操作的特性,发现空间手机版中的“签到”功能更符合用户在手表上的使用习惯。

    为用户打造一种“轻松、简单、趣味化”的签到模式,更加符合空间用户的使用场景。

    确定设计方向

    我们分析了空间手机版签到的设计风格和Apple Watch原生的UI风格。空间签到:卡通低龄 /图形复杂/静态单调,因此我们需要寻找一个新的突破点,使之更符合Apple Watch的风格设计,而非简单的移植。

    pic_007.png

    形随意动

    pic_008.png

    化繁为简,放弃手机端的插画风格,采用图形化的表达。图标更能明确表达意思,可帮助用户在使用快速理解不同签到含义,并且符合手表“简单”的要求。

    pic_009.gif

    pic_010.png

    提取元素,从而升华签到的氛围渲染。例如:星座签结合了星盘;天气签结合了古代天文台的元素;黄历签则融入八卦、日晷、12天干地支等元素。利用传统的元素融入现代化的设计风格,升华签到的深层次含义。

    pic_011.png

    pic_012.png

    每种颜色代表着不同的情绪或性格,每个星座拥有不同的性格。我们用不同的颜色来表达不同星座的特征,保证来每个星座的独立性和避免设计过于单调。

    pic_013.png

    pic_014.png

    趣味动画,丰富体验的趣味性与层级感,渲染内容本身所蕴含的意义,提升用户使用的愉悦感。

    pic_015.gif

    其他

    首页我们设计了一个笑脸来迎接你一天的心情,在首页滑动滚轮可以看到你在好友中的排名,点击即可炫耀。

    pic_016.png

    为了增强用户使用Apple Watch签到的特权感,我们全新优化了签到展示的图片,并且带有特权标识。

    pic_017.png

    不同的天气除了图标的区别之外,背景也会有差异化的表现,旨在渲染氛围,以提升视觉效果的沉浸感。

    pic_018.png

    小结

    我们通过图形、颜色、动画几个层面来不断优化与打磨设计方案,与此同时,在体验的层面也力求打造一种轻松、简单以及趣味化的签到模式,通过富有品质感的细节来提升设计的吸引力。

    展开全文
  • 1 展示网站项目需求 小型的外包项目,给客户 A 做一个产品展示网站,客户 ...3 传统方案解决网站展现项目-问题分析 需要的网站结构相似度很高,而且都不是高访问量网站,如果分成多个虚拟空间来处理,相当于一个相同网

    1 展示网站项目需求

    小型的外包项目,给客户 A 做一个产品展示网站,客户 A 的朋友感觉效果不错,也希望做这样的产品展示网站,但是要求都有些不同:

    1. 有客户要求以新闻的形式发布
    2. 有客户人要求以博客的形式发布
    3. 有客户希望以微信公众号的形式发布

    2 传统方案解决网站展现项目

    1. 直接复制粘贴一份,然后根据客户不同要求,进行定制修改
    2. 给每个网站租用一个空间
    3. 方案设计示意图
      在这里插入图片描述

    3 传统方案解决网站展现项目-问题分析

    1. 需要的网站结构相似度很高,而且都不是高访问量网站,如果分成多个虚拟空间来处理,相当于一个相同网站的实例对象很多,造成服务器的资源浪费
    2. 解决思路:整合到一个网站中,共享其相关的代码和数据,对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享,减少服务器资源
    3. 对于代码来说,由于是一份实例,维护和扩展都更加容易
    4. 上面的解决思路就可以使用 享元模式 来解决

    4 享元模式基本介绍

    基本介绍

    1. 享元模式(Flyweight Pattern) 也叫 蝇量模式: 运用共享技术有效地支持大量细粒度的对象
    2. 常用于系统底层开发,解决系统的性能问题。像数据库连接池,里面都是创建好的连接对象,在这些连接对象中有我们需要的则直接拿来用,避免重新创建,如果没有我们需要的,则创建一个
    3. 享元模式能够解决重复对象的内存浪费的问题,当系统中有大量相似对象,需要缓冲池时。不需总是创建新对象,可以从缓冲池里拿。这样可以降低系统内存,同时提高效率
    4. 享元模式经典的应用场景就是池技术了,String 常量池、数据库连接池、缓冲池等等都是享元模式的应用,享元模式是池技术的重要实现方式
      在这里插入图片描述

    5 享元模式的原理类图

    在这里插入图片描述
    对类图的说明
    对原理图的说明-即(模式的角色及职责)

    1. FlyWeight 是抽象的享元角色, 他是产品的抽象类, 同时定义出对象的外部状态内部状态(后面介绍) 的接口或实现
    2. ConcreteFlyWeight 是具体的享元角色,是具体的产品类,实现抽象角色定义相关业务
    3. UnSharedConcreteFlyWeight 是不可共享的角色,一般不会出现在享元工厂。
    4. FlyWeightFactory 享元工厂类,用于构建一个池容器(集合), 同时提供从池中获取对象方法

    6 内部状态和外部状态

    比如围棋、五子棋、跳棋,它们都有大量的棋子对象,围棋和五子棋只有黑白两色,跳棋颜色多一点,所以棋子颜色就是棋子的内部状态;而各个棋子之间的差别就是位置的不同,当我们落子后,落子颜色是定的,但位置是变化的,所以棋子坐标就是棋子的外部状态

    1. 享元模式提出了两个要求:细粒度和共享对象。这里就涉及到内部状态和外部状态了,即将对象的信息分为两个部分:内部状态和外部状态
    2. 内部状态指对象共享出来的信息,存储在享元对象内部且不会随环境的改变而改变
    3. 外部状态指对象得以依赖的一个标记,是随环境改变而改变的、不可共享的状态。
    4. 举个例子:围棋理论上有 361 个空位可以放棋子,每盘棋都有可能有两三百个棋子对象产生,因为内存空间有限,一台服务器很难支持更多的玩家玩围棋游戏,如果用享元模式来处理棋子,那么棋子对象就可以减少到只有两个实例,这样就很好的解决了对象的开销问题。

    7 享元模式解决网站展现项目

    1. 应用实例要求
      使用享元模式完成,前面提出的网站外包问题
    2. 思路分析和图解(类图)
      在这里插入图片描述
    package com.atguigu.flyweight;
    public class User {
    	private String name;
    	public User(String name) {
    		super();
    		this.name = name;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    
    package com.atguigu.flyweight;
    public abstract class WebSite {
    	public abstract void use(User user);//抽象方法
    }
    
    package com.atguigu.flyweight;
    //具体网站
    public class ConcreteWebSite extends WebSite {
    	//共享的部分,内部状态
    	private String type = ""; //网站发布的形式(类型)
    	//构造器
    	public ConcreteWebSite(String type) {
    		this.type = type;
    	}
    	@Override
    	public void use(User user) {
    		// TODO Auto-generated method stub
    		System.out.println("网站的发布形式为:" + type + " 在使用中 .. 使用者是" + user.getName());
    	}
    }
    
    package com.atguigu.flyweight;
    import java.util.HashMap;
    // 网站工厂类,根据需要返回压一个网站
    public class WebSiteFactory {
    	//集合, 充当池的作用
    	private HashMap<String, ConcreteWebSite> pool = new HashMap<>();
    	//根据网站的类型,返回一个网站, 如果没有就创建一个网站,并放入到池中,并返回
    	public WebSite getWebSiteCategory(String type) {
    		if(!pool.containsKey(type)) {
    			//就创建一个网站,并放入到池中
    			pool.put(type, new ConcreteWebSite(type));
    		}
    		return (WebSite)pool.get(type);	
    	}
    	//获取网站分类的总数 (池中有多少个网站类型)
    	public int getWebSiteCount() {
    		return pool.size();
    	}
    }
    
    package com.atguigu.flyweight;
    public class Client {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		// 创建一个工厂类
    		WebSiteFactory factory = new WebSiteFactory();
    		// 客户要一个以新闻形式发布的网站
    		WebSite webSite1 = factory.getWebSiteCategory("新闻");
    		webSite1.use(new User("tom"));
    		// 客户要一个以博客形式发布的网站
    		WebSite webSite2 = factory.getWebSiteCategory("博客");
    		webSite2.use(new User("jack"));
    		// 客户要一个以博客形式发布的网站
    		WebSite webSite3 = factory.getWebSiteCategory("博客");
    		webSite3.use(new User("smith"));
    		// 客户要一个以博客形式发布的网站
    		WebSite webSite4 = factory.getWebSiteCategory("博客");
    		webSite4.use(new User("king"));
    		System.out.println("网站的分类共=" + factory.getWebSiteCount());
    	}
    }
    

    在这里插入图片描述

    8 享元模式在 JDK-Interger 的应用源码分析

    1. Integer 中的享元模式
    2. 代码分析+Debug 源码+说明
    package com.atguigu.jdk;
    public class FlyWeight {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//如果 Integer.valueOf(x) x 在 -128 --- 127 直接,就是使用享元模式返回,如果不在
    		//范围类,则仍然 new
    		//小结:
    		//1. 在 valueOf 方法中,先判断值是否在 IntegerCache 中,如果不在,就创建新的 Integer(new), 否则,就直接从 缓存池返回
    		//2. valueOf 方法,就使用到享元模式
    		//3. 如果使用 valueOf 方法得到一个 Integer 实例,范围在 -128 - 127 ,执行速度比 new 快
    		Integer x = Integer.valueOf(127); // 得到 x 实例,类型 Integer
    		Integer y = new Integer(127); // 得到 y 实例,类型 Integer
    		Integer z = Integer.valueOf(127);//.. 
    		Integer w = new Integer(127);
    		System.out.println(x.equals(y)); // 大小,true
    		System.out.println(x == y ); // false
    		System.out.println(x == z ); // true
    		System.out.println(w == x ); // false
    		System.out.println(w == y ); // false
    		Integer x1 = Integer.valueOf(200);
    		Integer x2 = Integer.valueOf(200);
    		System.out.println("x1==x2" + (x1 == x2)); // false
    	}
    }
    

    在这里插入图片描述
    第一次new一个IntegerCache时候,首先创建一个cache数组,大小为(high-low)+1因为数组大小不能为负数

    在这里插入图片描述

    追踪valueof()发现如果 Integer.valueOf(x) 的x 在IntegerCache.low<=x<= IntegerCache.high范围内,则直接,就是使用享元模式返回,如果不在范围内,就new新的Integer一个返回
    在这里插入图片描述

    查看IntegerCache.low,IntegerCache.high的大小发现low=-128,high=127
    在这里插入图片描述

    9 享元模式的注意事项和细节

    1. 在享元模式这样理解,“享”就表示共享,“元”表示对象。
    2. 系统中有大量对象,这些对象消耗大量内存,并且对象的状态大部分可以外部化时,我们就可以考虑选用享元模式。
    3. 用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象,用 HashMap/HashTable 存储。
    4. 享元模式大大减少了对象的创建,降低了程序内存的占用,提高效率。
    5. 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态,而外部状态具有固化特性,不应该随着内部状态的改变而改变,这是我们使用享元模式需要注意的地方
    6. 使用享元模式时,注意划分内部状态和外部状态,并且需要有一个工厂类加以控制。
    7. 享元模式经典的应用场景是需要缓冲池的场景,比如 String 常量池、数据库连接池。
    展开全文
  • 《室内设计师的收纳设计手册》2019年室内设计师的收纳设计手册、室内设计师补充收纳设计灵感必备第一篇章《室内不同空间尺度与收纳系统分析》第二篇章《室内住宅收纳套路》第三篇章《家装平面空间收纳设计案例》第四...

    《室内设计师的收纳设计手册》

    2019年室内设计师的收纳设计手册、室内设计师补充收纳设计灵感必备

    第一篇章《室内不同空间尺度与收纳系统分析》

    第二篇章《室内住宅收纳套路》

    第三篇章《家装平面空间收纳设计案例》

    第四篇章《 室内空间收纳功能解析 》

    大小:760MB

    格式:JPG、PDF

    3b8aaeedee741dfd6ee6ea3c82067b33.png

    详细内容图片展示

    2a174791c9889f9337bbb56627467d51.png

    d6ded8647a7b90dcdac45a8176b41b53.png

    e6864a9af799fe16a0b473a138dc0b93.png

    dabad11d0d326a766613822f15d651f8.png

    今日分享到此,希望本篇文章给你带来一点收获,如果你有什么更好的想法或建议可以在下方回复留言,或给小编发私信,小编将第一时间给与你回复,更多设计类资讯分享给你,想要了解更多专业设计资讯

    小编也开通了专栏“室内设计设区”想要进一步了解室内设计的朋友欢迎大家加入,每周文章分享到专栏内供大家共同探讨交流!V/1443750941

    展开全文
  • 触觉式虚拟设计系统是设计师在利用视觉器官的基础上,进一步应用触觉器官开展设计工作的系统。介绍了触觉和触觉反馈概念,讨论了触觉设计优势,分析了...风机叶轮的触觉式虚拟设计案例展示了该设计方法的基本工作流程。
  • 通过40个案例分析,从原理到概念,从草图到细化的版式,一直到完成作品的深度分析,将理论运用于实践。 分享全球知名专业设计师在激发灵感、工作流程、采用方法,以及创意问题解决上的经验与心得。 内容简介  ...
  • 最后进入测试方法,展示需求 HBase实战之谷粒微博 需求分析 微博内容的浏览,数据库表设计 用户社交体现:关注用户,取关用户 拉取关注的人的微博内容 表的分类 1.微博内容表 表结构: 方法名 creat...

    HBase实战之谷粒微博

    需求分析

    1. 微博内容的浏览,数据库表设计

    2. 用户社交体现:关注用户,取关用户

    3. 拉取关注的人的微博内容

    表的分类

    1.微博内容表

    表结构:

    方法名 creatTableeContent
    Table Name weibo:content
    RowKey 用户 ID_时间戳
    ColumnFamily info
    ColumnLabel 标题,内容,图片
    Version 1 个版本

    2.用户关系表

    表结构:

    方法名 createTableRelations
    Table Name weibo:relation
    RowKey 用户 ID
    ColumnFamily attends、fans
    ColumnLabel 关注用户 ID,粉丝用户 ID
    ColumnValue 用户 ID
    Version 1 个版本

    3.微博收件箱表

    表结构:

    方法名 createTableReceiveContentEmails
    Table Name weibo:inbox
    RowKey 用户 ID
    ColumnFamily info
    ColumnLabel 用户 ID
    ColumnValue 取微博内容的 RowKey
    Version 2

    代码实现

    1.代码设计总览:

    1. 创建命名空间以及表名的定义

    2. 创建微博内容表

    3. 创建用户关系表

    4. 创建用户微博内容接收邮件表

    5. 发布微博内容

    6. 添加关注用户

    7. 移除(取关)用户

    8. 获取关注的人的微博内容

    9. 测试

    2. 环境搭建

    1.pom文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>Hadoop</artifactId>
            <groupId>com.huan</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>guli-weibo</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-server</artifactId>
                <version>1.3.1</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-client</artifactId>
                <version>1.3.1</version>
            </dependency>
        </dependencies>
    </project>
    

    2.包名规则

    在这里插入图片描述

    3.resources文件 (hbase-site.xml 可以直接在本地运行,无需打包jar)

    <?xml version="1.0"?>
    <?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
    <!--
    /**
     *
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements.  See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership.  The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License.  You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    -->
    <configuration>
        <property>  
            <name>hbase.rootdir</name>  
            <value>hdfs://Bigdata01:9000/hbase</value>  
        </property>
    
        <property>  
            <name>hbase.cluster.distributed</name>
            <value>true</value>
        </property>
    
        <!-- 0.98后的新变动,之前版本没有.port,默认端口为60000 -->
        <property>
            <name>hbase.master.port</name>
            <value>16000</value>
        </property>
    
        <property>  
            <name>hbase.zookeeper.quorum</name>
            <value>Bigdata01:2181,Bigdata02:2181,Bigdata03:2181</value>
        </property>
    
        <property>  
            <name>hbase.zookeeper.property.dataDir</name>
            <value>/opt/module/zookeeper-3.4.10/zkData</value>
        </property>
        <property>
            <name>hbase.master.maxclockskew</name>
            <value>180000</value>
            <description>Time difference of regionserver from master</description>
        </property>
    </configuration>
    

    3.创建命名空间以及表名的定义

    这里我们设置一个常量给它们定义好方便后续的使用,在后续使用时直接调用即可:

    package com.huan.constants;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.HBaseConfiguration;
    
    
    
    public class Constants {
    
        //TODO 定义上下文配置信息
        public static final Configuration CONFIGURATION = HBaseConfiguration.create();
    
        //TODO 定义命名空间
        public static final String NAMESPACE = "weibo";
    
        //TODO 微博内容表
        public static final String CONTENT_TABLE = "weibo:content";
        public static final String CONTENT_TABLE_CF = "info";
        public static final int CONTENT_TABLE_VERSION = 1;
    
        //TODO 用户关系表
        public static final String RELATION_TABLE = "weibo:relation";
        public static final String RELATION_TABLE_CF1 = "attends";
        public static final String RELATION_TABLE_CF2 = "fans";
        public static final int RELATION_TABLE_VERSION = 1;
    
        //TODO 收件箱表
        public static final String INBOX_TABLE = "weibo:inbox";
        public static final String INBOX_TABLE_CF = "info";
        public static final int INBOX_TABLE_VERSION = 2;
    }
    

    4.设置一个工具类,在工具类里面将命名空间和表的参数设置好方便后续调用

    package com.huan.utils;
    
    import com.huan.constants.Constants;
    import org.apache.hadoop.hbase.HColumnDescriptor;
    import org.apache.hadoop.hbase.HTableDescriptor;
    import org.apache.hadoop.hbase.NamespaceDescriptor;
    import org.apache.hadoop.hbase.TableName;
    import org.apache.hadoop.hbase.client.Admin;
    import org.apache.hadoop.hbase.client.Connection;
    import org.apache.hadoop.hbase.client.ConnectionFactory;
    
    import java.io.IOException;
    
    /**
     * 1.创建命名空间
     * 2.判断表是否存在
     * 3.创建表 (三张表)
     *
     */
    public class HBaseUtils {
    
        public static Connection connection = null;
        public static Admin admin = null;
    
    
        //TODO 1.创建命名空间
        public static void createNameSpace(String nameSpace) throws IOException {
    
            //1.获取Connection对象
            connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
            //2.获取Admin对象
            admin = connection.getAdmin();
    
            //3.构建命名空间描述器
            NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create( nameSpace ).build();
    
            //4.创建命名空间
            admin.createNamespace( namespaceDescriptor );
    
            //5.关闭资源
            admin.close();
            connection.close();
        }
    
        //TODO 2.判断表是否存在
        public static boolean isTableExist(String tableName) throws IOException {
    
            //1.判断表是否存在
            boolean exists = admin.tableExists( TableName.valueOf( tableName ) );
    
            //2.关闭资源
            admin.close();
            connection.close();
    
            //3.返回结果
            return exists;
        }
    
        //TODO 3.创建表
        public static void createTable(String tableName,int version,String... cfs) throws IOException {
            //1.判断是否传入了列族信息
            if(cfs.length < 0){
                System.out.println("请设置列族信息");
                return;
            }
    
            //2.判断表是否存在
            if(isTableExist( tableName )){
                System.out.println(tableName+"表已存在");
                return;
            }
            //3.获取Connection对象
            connection = ConnectionFactory.createConnection(Constants.CONFIGURATION);
            //4.获取Admin对象
            admin = connection.getAdmin();
            //5.创建表描述器
            HTableDescriptor hTableDescriptor = new HTableDescriptor( TableName.valueOf( tableName ) );
            //6.循环添加列族信息
            for (String cf : cfs) {
                //遍历列族
                HColumnDescriptor hColumnDescriptor = new HColumnDescriptor( cf );
                //7.设置版本
                hColumnDescriptor.setMaxVersions( version );
    
                hTableDescriptor.addFamily( hColumnDescriptor );
            }
    
            //8.创建表操作
            admin.createTable( hTableDescriptor );
            //9.关闭资源
            admin.close();
            connection.close();
        }
    
    }
    
    

    5.写好相应的业务需求方便测试调用

    package com.huan.dao;
    
    import com.huan.constants.Constants;
    import com.huan.utils.HBaseUtils;
    import org.apache.hadoop.hbase.Cell;
    import org.apache.hadoop.hbase.CellUtil;
    import org.apache.hadoop.hbase.TableName;
    import org.apache.hadoop.hbase.client.*;
    import org.apache.hadoop.hbase.filter.CompareFilter;
    import org.apache.hadoop.hbase.filter.RowFilter;
    import org.apache.hadoop.hbase.filter.SubstringComparator;
    import org.apache.hadoop.hbase.util.Bytes;
    
    import java.io.IOException;
    import java.util.ArrayList;
    
    /**
     * 1.发布微博
     * 2.删除微博
     * 3.关注用户
     * 4.取关用户
     * 5.获取用户初始化界面
     * 6.获取微博详情
     */
    public class HBaseDao {
    
        //TODO 1.发布微博
        public static void publishWeiBo(String uid, String content) throws IOException {
            //1.获取Connection对象
            Connection connection = HBaseUtils.connection;
            connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
    
            //第一部分:操作微博内容表
            //1.获取微博内容表对象
            Table contTable = connection.getTable( TableName.valueOf( Constants.CONTENT_TABLE ) );
    
            //2.获取当前时间戳
            long ts = System.currentTimeMillis();
    
            //3.获取RowKey
            String rowKey = uid + "_" + ts;
    
            //4.创建Put对象
            Put contPut = new Put( Bytes.toBytes( rowKey ) );
            //5.给Put对象赋值
            contPut.addColumn( Bytes.toBytes( Constants.CONTENT_TABLE_CF ), Bytes.toBytes( "content" ), Bytes.toBytes( content ) );
            //6.执行插入数据操作
            contTable.put( contPut );
    
            //第二部分操作微博收件箱表
            //1.获取用户关系表对象
            Table relaTable = connection.getTable( TableName.valueOf( Constants.RELATION_TABLE ) );
    
            //2.获取当前发布微博人的fans列族数据
            Get get = new Get( Bytes.toBytes( uid ) );
            Result result = relaTable.get( get );
    
            //3.创建一个集合,用户存放微博内容表的Put对象
            ArrayList<Put> inboxPuts = new ArrayList<>();
            //4.遍历粉丝
            for (Cell cell : result.rawCells()) {
                //5.构建微博收件箱表的Put对象
                Put inboxPut = new Put( CellUtil.cloneQualifier( cell ) );
    
                //6.给收件箱表的Put对象赋值
                inboxPut.addColumn( Bytes.toBytes( Constants.INBOX_TABLE_CF ), Bytes.toBytes( uid ), Bytes.toBytes( rowKey ) );
    
                //7.将收件箱表的Put对象存入集合
                inboxPuts.add( inboxPut );
            }
    
            //8.判断是否有粉丝
            if (inboxPuts.size() > 0) {
                //获取收件箱表对象
                Table inboxTable = connection.getTable( TableName.valueOf( Constants.INBOX_TABLE ) );
    
                //执行收件箱表数据插入操作
                inboxTable.put( inboxPuts );
    
                //关闭收件箱表
                inboxTable.close();
    
            }
    
            //关闭资源(关系表和内容表)
            relaTable.close();
            contTable.close();
            connection.close();
        }
    
        //TODO 2.关注用户
        public static void addAttends(String uid, String... attends) throws IOException {
            //1.校验是否添加了待关注的人
            if (attends.length <= 0) {
                System.out.println( "请选择待关注的人。。。" );
                return;
            }
    
            //获取Connection对象
            Connection connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
    
            //第一部分:操作用户关系表
            //1.获取用户关系表对象
            Table relaTable = connection.getTable( TableName.valueOf( Constants.RELATION_TABLE ) );
            //2.创建一个集合,用于存放用户关系表的Put对象
            ArrayList<Put> relaPuts = new ArrayList<>();
            //3.创建操作者的Put对象
            Put uidPut = new Put( Bytes.toBytes( uid ) );
            //4.循环创建被故被关注者的Put对象
            for (String attend : attends) {
                //5.给操作者的Put对象赋值
                uidPut.addColumn( Bytes.toBytes(Constants.RELATION_TABLE_CF1),Bytes.toBytes(attend),Bytes.toBytes(attend));
                //6.创建被关注着的Put对象
                Put attendPut = new Put( Bytes.toBytes( attend ) );
                //7.给被关注着的Put对象复制
                attendPut.addColumn( Bytes.toBytes( Constants.RELATION_TABLE_CF2 ), Bytes.toBytes( uid ), Bytes.toBytes( uid ) );
                //8.将被关注着的Put对象放入集合
                relaPuts.add( attendPut );
            }
            //9.将操作者的Put对象添加至集合
            relaPuts.add( uidPut );
    
            //10.执行用户关系表插入数据操作
            relaTable.put( relaPuts );
    
            //第二部分:操作收件箱表
            //1.获取微博内容表
            Table contTable = connection.getTable( TableName.valueOf( Constants.CONTENT_TABLE ) );
            //2.创建收件箱表的Put对象
            Put inboxPut = new Put( Bytes.toBytes( uid ) );
            //3.循环attends,获取每个被关注者的近期发布的微博
            for (String attend:attends) {
    
                //4.获取当前被关注者近期发布的微博 (Scan) -> 集合ResultScanner
                Scan scan = new Scan(Bytes.toBytes(attend+"_"  ),Bytes.toBytes( attend+ "|" ));
                ResultScanner resultScanner = contTable.getScanner( scan );
    
                //TODO 定义一个时间戳
                long ts = System.currentTimeMillis();
    
                //5.获取的值进行遍历
                for (Result result:resultScanner) {
    
                    //6.给收件箱表的Put对象赋值
                    inboxPut.addColumn( Bytes.toBytes( Constants.INBOX_TABLE_CF )
                    ,Bytes.toBytes(attend  ),ts++,result.getRow());
                }
            }
            //7.判断当前的Put对象是否为空
            if (!inboxPut.isEmpty()){
    
                //8.获取收件箱表数据
                Table inboxTable = connection.getTable( TableName.valueOf( Constants.INBOX_TABLE ) );
                //9.插入数据
                inboxTable.put( inboxPut );
                //10.关闭收件箱连接
                inboxTable.close();
            }
    
            //关闭资源
            relaTable.close();
            contTable.close();
            connection.close();
        }
    
        //TODO 3.取关用户
        public static void deleteAttends(String uid,String... dels) throws IOException {
    
            if (dels.length <= 0){
                System.out.println("请添加取关的用户");
                return;
            }
    
            //获取Connection对象
            Connection connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
            //第一部分:操作用户关系表
            //1.获取用户关系表
            Table relaTable = connection.getTable( TableName.valueOf( Constants.RELATION_TABLE ) );
            //2.创建一个集合,用于存放用户关系表的Delete对象
            ArrayList<Delete> relaDeletes = new ArrayList<>();
            //3.创建操作者的Delete对象
            Delete uidDelete = new Delete( Bytes.toBytes( uid ) );
            //4.循环创建被取关者的Delete对象
            for (String del:dels) {
    
                //5.给操作者Delete对象赋值
                uidDelete.addColumn( Bytes.toBytes( Constants.RELATION_TABLE_CF1 ),
                        Bytes.toBytes( del ));
                //6.创建被取关者的Delete对象
                Delete delDelete = new Delete( Bytes.toBytes( del ) );
                //7.给被取关者的Delete对象赋值
                delDelete.addColumn( Bytes.toBytes( Constants.RELATION_TABLE_CF2 ),Bytes.toBytes( uid ) );
                //8.将被取关者的Delete对象添加至集合
                relaDeletes.add( delDelete );
            }
    
            //9.将操作者的Delete对象添加至集合
            relaDeletes.add( uidDelete );
            //10.执行用户关系表的删除操作
            relaTable.delete( relaDeletes );
            //第二部分:操作收件箱表
            //1.获取收件箱表对象
            Table inboxTable = connection.getTable( TableName.valueOf( Constants.INBOX_TABLE ) );
            //2.创建操作者的Delete对象
            Delete inboxDelete = new Delete( Bytes.toBytes( uid ) );
            //3.给操作者的Delete对象赋值
            for (String del : dels) {
                inboxDelete.addColumn( Bytes.toBytes( Constants.INBOX_TABLE_CF ),Bytes.toBytes( del ) );
            }
    
            //4.执行收件箱表的删除操作
            inboxTable.delete( inboxDelete );
    
            //关闭资源
            relaTable.close();
            inboxTable.close();
            connection.close();
    
        }
    
        //TODO 4.获取初始化页面数据
        public static void getInt(String uid) throws IOException {
            //获取Connection对象
            Connection connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
            //1.获取收件箱表对象
            Table inboxTable = connection.getTable( TableName.valueOf( Constants.INBOX_TABLE ) );
            //2.获取微博内容表对象
            Table contTable = connection.getTable( TableName.valueOf( Constants.CONTENT_TABLE ) );
    
            //3.创建收件箱表Get对象,并获取数据(设置最大版本)
            Get inboxGet = new Get( Bytes.toBytes( uid ) );
            inboxGet.setMaxVersions();
            Result result = inboxTable.get( inboxGet );
            //4.遍历获取的数据
            for (Cell cell : result.rawCells()){
    
                //5.构建微博内容表Get对象
                Get contGet = new Get( CellUtil.cloneValue( cell ) );
                //6.获取该Get对象的数据内容
                Result contResult = contTable.get( contGet );
    
                //7.解析内容并打印
                for (Cell contCell : contResult.rawCells()) {
    
                    System.out.println("PK:"+Bytes.toString(  CellUtil.cloneRow( contCell ))
                    +",CF:"+Bytes.toString( CellUtil.cloneFamily( contCell ) )
                    +",CN:"+Bytes.toString( CellUtil.cloneQualifier( contCell ) )
                    +",Value:"+Bytes.toString( CellUtil.cloneValue( contCell ) ));
                }
            }
            //关闭资源
            inboxTable.close();
            contTable.close();
            connection.close();
    
        }
    
        //TODO 5.获取用户初始化界面 (获取某个人所有微博详情)
        public static void getWeiBo(String uid) throws IOException {
            //1.获取Connection对象
            Connection connection = ConnectionFactory.createConnection( Constants.CONFIGURATION );
            //2.获取微博内容表对象
            Table table = connection.getTable( TableName.valueOf( Constants.CONTENT_TABLE ) );
            //3.构建Scan对象
            Scan scan = new Scan();
    
            //构建过滤器
            RowFilter rowFilter = new RowFilter( CompareFilter.CompareOp. EQUAL,new SubstringComparator( uid+"_"));
            scan.setFilter( rowFilter );
    
            //4.获取数据
            ResultScanner resultScanner = table.getScanner( scan );
            //5.解析数据并打印
            for (Result result : resultScanner) {
                for (Cell cell : result.rawCells()) {
    
                    System.out.println("PK:"+Bytes.toString(  CellUtil.cloneRow( cell ))
                            +",CF:"+Bytes.toString( CellUtil.cloneFamily( cell ) )
                            +",CN:"+Bytes.toString( CellUtil.cloneQualifier( cell ) )
                            +",Value:"+Bytes.toString( CellUtil.cloneValue( cell ) ));
                }
            }
    
    
            //6.关闭资源
            table.close();
            connection.close();
    
        }
    
    }
    

    6.最后进入测试方法,展示需求

    package com.huan;
    
    import com.huan.constants.Constants;
    import com.huan.dao.HBaseDao;
    import com.huan.utils.HBaseUtils;
    
    import java.io.IOException;
    
    public class WeiBoTest {
    
        public static void init(){
    
            try {
                //1.创建命名空间
                HBaseUtils.createNameSpace( Constants.NAMESPACE );
                //2.创建微博内容表
                HBaseUtils.createTable( Constants.CONTENT_TABLE,Constants.CONTENT_TABLE_VERSION,Constants.CONTENT_TABLE_CF );
                //3.创建用户关系表
                HBaseUtils.createTable( Constants.RELATION_TABLE,Constants.RELATION_TABLE_VERSION,Constants.RELATION_TABLE_CF1,Constants.RELATION_TABLE_CF2 );
                //4.创建收件箱表
                HBaseUtils.createTable( Constants.INBOX_TABLE,Constants.INBOX_TABLE_VERSION,Constants.INBOX_TABLE_CF );
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws IOException, InterruptedException {
    
            /**
             * 1001:昊哥
             * 1002:不明人物
             * 1003:大欢欢
             */
    
            //TODO 1.初始化
            init();
            //TODO 1001发布微博
            HBaseDao.publishWeiBo( "1001","昊哥爱欢欢!!!" );
            //TODO 1002关注1001和1003
            HBaseDao.addAttends( "1002","1001","1003" );
            //TODO 获取1002初始化界面
            HBaseDao.getInt( "1002" );
            System.out.println("-------------1111----------------");
            //TODO 1003发布3条微博,同时1001发布2条微博
            HBaseDao.publishWeiBo( "1003","欢欢也爱昊哥");
            Thread.sleep( 10 );
            HBaseDao.publishWeiBo( "1001","爱你爱你,满脑子都是你");
            Thread.sleep( 10 );
            HBaseDao.publishWeiBo( "1003","真的丫,欢欢也是!!");
            Thread.sleep( 10 );
            HBaseDao.publishWeiBo( "1001","亲亲我的猪");
            Thread.sleep( 10 );
            HBaseDao.publishWeiBo( "1003","欢欢害羞!!");
            //TODO 再次获取1002初始化界面
            HBaseDao.getInt("1002"  );
            System.out.println("-------------2222-------------");
            //TODO 1002取关1003
            HBaseDao.deleteAttends( "1002","1003" );
            //TODO 再次获取1002初始化界面
            HBaseDao.getInt("1002"  );
            System.out.println("-------------3333-------------");
            //TODO 1002再次关注1003
            HBaseDao.addAttends( "1002","1003" );
            //TODO 获取1002初始化页面
            HBaseDao.getInt("1002"  );
            System.out.println("-------------4444--------------");
    
            //TODO 获取1001微博详情
            HBaseDao.getWeiBo( "1001" );
        }
    
    }
    
    展开全文
  •  《oracle dba手记2:数据库诊断案例与内部恢复实践》的主要内容以原理分析、内容实践、故障解决为依据,将oracle数据库的深层技术层剖缕析抽丝剥茧地展示给读者。希望能够帮助读者加深对于oracle技术的认知和理解,...
  • 全程进行细致的分析说明,使读者能够全面地理解案例制作过程,并解决说什么、对谁说和怎样说的关键问题,最后还提供了大量的成功案例,并对其进行分析展示,使读者在欣赏的同时也能提高自己的审美和设计能力,达到从...
  • 任务119: 案例分析_大气质量(基于Power View界面)制作仪表板 任务120: 案例分析_大气质量(切片器样式处理) 任务121: 案例分析_大气质量(控件绑定) 任务122: 案例分析_大气质量(组合图实现) 任务123: 案例分析_...
  • ASM案例分析与诊断(作者:杨廷琨) 103 ASM实例连接之ORA-1012错误分析 104 ASM空间扩展故障解决 111 ASM创建表空间之ORA-569错误解决 115 一次监听故障的诊断与处理(作者:熊军) 121 问题诊断分析 122 ...
  • 运用RUP 4+1视图方法进行软件架构设计温 昱 (wenyu@china.com), 松耦合空间网站 技术咨询顾问要开发出用户满意的软件并不是件容易的事,软件...本文从理解需求种类的复杂性谈起,通过具体案例分析展示了如何通过R
  • 《字体设计的规则与艺》分析了大量历史上的经典字体及现代字体,并展示了很多学生作品的典型案例,将理论与实际操作相结合,不但能使读者掌握字体设计的规律,还能为他们打开创作思路。 《字体设计的规则与艺》适用...
  • Sanz 等人后续推进了这方面的研究,其依据爆管的水量变化过程,不断校核管网模型的空间分布参数,其结果展示出了较高的爆管定位精度;等人利用监测资料与低压供水模型相结合的管网爆管水力学模型实现了爆管定位,并...
  • 设计一张海报可能是一项具有挑战性的任务。...仔细看看这些设计,深层的层层分析优秀案例设计思路。 注意他们的颜色选择、设计风格,以及他们如何通过形状、排版和空白空间来控制观众的注意力。 合
  • 营销型网站策划与成交型网站设计要素案例分析2.企业域名 ; 网站备案; 网站空间 ; 使用FTP软件上传方法3.博客、企业站、资讯站、电商站、社区站建设、快速搭建企业展示型网站,图片处理技巧4.网页代码知识、xh...
  • LuceneInAction(第2版)_中文版

    千次下载 热门讨论 2012-07-12 09:52:59
    从Lucene核心、Lucene应用、案例分析3个方面详细系统地介绍了Lucene,包括认识Lucene、建立索引、为应用程序添加搜索功能、高级搜索技术、扩展搜索、使用Tika提取文本、Lucene的高级扩展、使用其他编程语言访问...
  • OPENCL异构计算.pdf

    2018-05-18 13:37:28
    《OpenCL异构计算》讲解了OpenCL和如何为复杂的...并解释一些映射到各种体系结构的折衷方案, · 提出一系列基础编程技术,并通过若干个实例和案例分析展示针对不同硬件平台的OpenCL扩展, 本书配套网站提供本书相关信
  • opencl异构计算

    2017-07-30 13:05:40
    并解释一些映射到各种体系结构的折衷方案, · 提出一系列基础编程技术,并通过若干个实例和案例分析展示针对不同硬件平台的OpenCL扩展, 本书配套网站提供本书相关信息、各章包含的示意图、范例代码、附加示例及...
  • Lucene实战(第2版) 中文版

    热门讨论 2013-03-20 11:04:29
    从lucene核心、lucene应用、案例分析3个方面详细系统地介绍了lucene,包括认识lucene、建立索引、为应用程序添加搜索功能、高级搜索技术、扩展搜索、使用tika提取文本、lucene的高级扩展、使用其他编程语言访问...
  • ASP.NET精品课程+源代码

    千次下载 热门讨论 2009-01-05 20:15:51
    我们在实训课题引入的前提下,通过一系列完整的案例分析来帮助学生学会ASP.NET知识,使学生由浅入深逐步掌握ASP.NET主要技术领域以及分布式应用程序开发,提高解决实际问题的能力。并为学生的终生学习做了良好的铺垫...
  • 本书共16章,分为4篇,详细讲解了使用各种软件和平台进行音、视频多媒体编程的技术,以案例为对象展示实现过程、分析技术难点。主要内容包括软件Visual C++2005的开发技术、DirectSound开发音频、DirectShow/VFW开发...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 125
精华内容 50
关键字:

展示空间设计案例分析