精华内容
下载资源
问答
  • 同时随着生活水平的提高和大家对物质需求的提升,产品包装不仅仅只是停留在了基本功能的使用上 ,更多的时候,越来越趋向于展示和欣赏上。产品包装设计得怎么样?包装是否精致美观也成为了包装设计行业的一大竞争...

    随着制作业的飞速发展,产品包装设计越来越成为市场上不可或缺的一部分;同时随着生活水平的提高和大家对物质需求的提升,产品包装不仅仅只是停留在了基本功能的使用上 ,更多的时候,越来越趋向于展示和欣赏上。产品包装设计得怎么样?包装是否精致美观也成为了包装设计行业的一大竞争优势,自然而然的 ,专业的包装设计公司也象雨后春 笋般的出现。正所谓没有规矩不成方圆,任何一件事物的制作和完成都有其特有的标志和准则,包装设计也不例外,下面天莫传媒包装设计公司就产品包装设计需要注意哪些问题 来展开分析,产品包装设计应该注意哪些问题?

    首先,满足基本功能的同时也要做好材料的选取

    众所周知,包装的基本功能就是将产品包裹起来装在盒子里,但是不同的产品有不同的优势和特性,相对来说一个高端产品如果说配备上简简单单的包装的话,那整个产品看着就 有些黯然失色,很多时候,包装一眼看上去就精致美观的话,心里就都会认为里面装的肯定是价格不菲的产品;因此在产品包装设计过程中,不同的产品包装选取不同的材料也显 得尤为重要,如果从材料上来说:纸盒,铁盒,木盒,布盒,皮盒,亚克力盒,瓦楞包装盒、pvc盒,都是产品设计中常用的材料,根据产品的性质和定位选择相对于的材料,从 某种意义上来说,可以让你的产品脱颖而出。

    f0a9f87f9c8e5f2d522c392732b71608.png

    其次,产品包装设计也是企业信息传递的载体

    如果说广告是最为企业宣传最基本的方式之一的话,那么产品包装就是企业信息传递的载体;如果说成千上万的产品包装制作出来后,没有任何有效的信息的话,那肯定的,这个包装设计是失败的。在有效面积的包装上体现出完善的企业信息是包装设计基本元素之一,有效的产品信息的传递可以让用户一目了然的对产品特定和企业信息的传达,只有这样才能发挥产品包装的真正作用。

    0394d55a8d6c2c3b9cb1cdfe3df9c6a3.png

    最后,个性化产品包装设计才能博得用户眼球

    市场上任何一件产品相对来说肯定少不了竞争力,哪怕说相同的产品也会有自身的竞争市场;用户购买产品的时候,除了关心产品价格以外,另一方面还会留意产品包装是否精美大方,能否给人惊喜的感觉。如果从产品包装设计上来看都是千篇一律的话,那这个产品肯定是不容易让客户牢记的。包装设计的独特性和个性化才能加深用户对产品的印象;别具一格的产品包装设计不仅仅能让你的产品不同其它同类的产品,同时也能体现出企业的特有风格和品位,这无疑也是企业宣传的一条捷径之路。

    因此,产品包装设计不仅仅是为了满足产品的基本功能需求,更大的程度上是为了更好的体现出产品的卖点和对企业形象的一种宣传手法,作为任何一家企业都是不能忽略的。

    展开全文
  • 我们先来看一下Java中的基数据类型有哪些: 从上图我们能够看到数据类型主题氛围两类,基本数据类型和引用数据类型,但是为何我们要把它分为两类呢,这是由它底层的存储的位置决定了它的们拥有各自特殊的功能性质,...

    基本数据类型和包装类指什么

    我们先来看一下Java中的基数据类型有哪些:
    在这里插入图片描述
    从上图我们能够看到数据类型主题氛围两类,基本数据类型和引用数据类型,但是为何我们要把它分为两类呢,这是由它底层的存储的位置决定了它的们拥有各自特殊的功能性质,我们这里先了解后面会详细赘述。
    我们这里在看基本数据类型,这里面有八种基本数据类型,它们都有自己对应的包装类型。
    在这里插入图片描述
    这里我们会有疑问为何会有包装类型,它能干什么,它们两个有什么区别、、、种种疑问。还是前面说的,一个东西性质是由它底层决定的,我们这里只是开个头,后面整篇文章看完后这些问题都会解决。

    装箱以及拆箱

    基本数据类型和包装类型直接的转换我们称之为装箱和拆箱操作。而我们的装箱以及拆箱操作在JDK5之前装箱以及拆箱只能程序员手动来操作,但是在JDK5之后就有了自动装箱以及拆箱,但是自动装箱以及拆箱原理和我们手动一样。这里我们先来看一下装箱以及拆箱的实现,之后我们在去看原理解决前一段后面的疑问。

    • 手动/自动装箱
    int a1=4;
    //手动装箱
          Integer ai = new Integer(a1);
    //自动装箱
         Integer aj = a1;
    
    
    • 手动/自动拆箱
    //手动拆箱
    int ah = ai.intValue();
     //自动拆箱
     int ag = ai;
    
    

    这里我们只是把自动装箱和拆箱开了个头,让大家看看,具体里面东西还要结合底层来说。

    自动装箱与拆箱的实现原理(基本数据类型和包装类存储在哪)

    基本数据类型存储位置

    我们先来说我们基本数据类型都存储在我们的Class常量池中。而我们的常量池属于方法区。

    包装类型的存储位置、自动装箱与拆箱的实现原理

    下面例子是自动装箱和拆箱带来的疑惑

    
        public class Test {  
            public static void main(String[] args) {      
                test();  
            }  
        
            public static void test() {  
                int i = 40;  
                int i0 = 40;  
                Integer i1 = 40;  
                Integer i2 = 40;  
                Integer i3 = 0;  
                Integer i4 = new Integer(40);  
                Integer i5 = new Integer(40);  
                Integer i6 = new Integer(0);  
                Integer i7=128;
                Integer i8=128;
                Double d1=1.0;  
                Double d2=1.0;  
                  
                System.out.println("i=i0\t" + (i == i0));  
                System.out.println("i1=i2\t" + (i1 == i2));  
                System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));  
                System.out.println("i4=i5\t" + (i4 == i5));  
                System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));
                System.out.println("i7==i8"+(i7==i8));      
                System.out.println("d1=d2\t" + (d1==d2));   
                  
                System.out.println();          
            }  
        } 
    

    请看下面的输出结果跟你预期的一样吗?
    输出的结果:
    i=i0        true
    i1=i2       true
    i1=i2+i3    true
    i4=i5       false
    i4=i5+i6    true
    i7=i8 false
    d1=d2     false

    为什么会这样?带着疑问继续往下看。
    自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
    双等号运算符==,对于基本数据类型比较的是数值,对于两个对象则比较的是地址

    明白自动装箱和拆箱的原理后,我们带着上面的疑问进行分析下Integer的自动装箱的实现源码。如下:

    
        public static Integer valueOf(int i) {
            //判断i是否在-128和127之间,存在则从IntegerCache中获取包装类的实例,否则new一个新实例
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    
    
        //使用亨元模式,来减少对象的创建(亨元设计模式大家有必要了解一下,我认为是最简单的设计模式,也许大家经常在项目中使用,不知道他的名字而已)
        private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            //静态方法,类加载的时候进行初始化cache[],静态变量存放在常量池中
            static {
                // high value may be configured by property
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
                        // If the property cannot be parsed into an int, ignore it.
                    }
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
    
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    
            private IntegerCache() {}
        }
    

    Integer i1 = 40; 自动装箱,相当于调用了Integer.valueOf(40);方法。
        首先判断i值是否在-128和127之间,如果在-128和127之间则直接从IntegerCache.cache缓存中获取指定数字的包装类;不存在则new出一个新的包装类。
        IntegerCache内部实现了一个Integer的静态常量数组,在类加载的时候,执行static静态块进行初始化-128到127之间的Integer对象,存放到cache数组中。cache属于常量,存放在java的方法区中。

    接着看下面是java8种基本类型的自动装箱代码实现。如下

        //boolean原生类型自动装箱成Boolean
        public static Boolean valueOf(boolean b) {
            return (b ? TRUE : FALSE);
        }
    
        //byte原生类型自动装箱成Byte
        public static Byte valueOf(byte b) {
            final int offset = 128;
            return ByteCache.cache[(int)b + offset];
        }
    
        //byte原生类型自动装箱成Byte
        public static Short valueOf(short s) {
            final int offset = 128;
            int sAsInt = s;
            if (sAsInt >= -128 && sAsInt <= 127) { // must cache
                return ShortCache.cache[sAsInt + offset];
            }
            return new Short(s);
        }
    
        //char原生类型自动装箱成Character
        public static Character valueOf(char c) {
            if (c <= 127) { // must cache
                return CharacterCache.cache[(int)c];
            }
            return new Character(c);
        }
        
        //int原生类型自动装箱成Integer
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    
        //int原生类型自动装箱成Long
        public static Long valueOf(long l) {
            final int offset = 128;
            if (l >= -128 && l <= 127) { // will cache
                return LongCache.cache[(int)l + offset];
            }
            return new Long(l);
        }
    
        //double原生类型自动装箱成Double
        public static Double valueOf(double d) {
            return new Double(d);
        }
    
        //float原生类型自动装箱成Float
        public static Float valueOf(float f) {
            return new Float(f);
        }
    

    通过分析源码发现,只有double和float的自动装箱代码没有使用缓存,每次都是new 新的对象,其它的6种基本类型都使用了缓存策略。
        使用缓存策略是因为,缓存的这些对象都是经常使用到的(如字符、-128至127之间的数字),防止每次自动装箱都创建一次对象的实例。
        而double、float是浮点型的,没有特别的热的(经常使用到的)数据的,缓存效果没有其它几种类型使用效率高。
        
    这个很好理解,因为对于Integer,在(-128,128]之间只有固定的256个值,所以为了避免多次创建对象,我们事先就创建好一个大小为256的Integer数组SMALL_VALUES,所以如果值在这个范围内,就可以直接返回我们事先创建好的对象就可以了。

    但是对于Double类型来说,我们就不能这样做,因为它在这个范围内个数是无限的。
    总结一句就是:在某个范围内的整型数值的个数是有限的,而浮点数却不是。

    下面在看下装箱和拆箱问题解惑。

        //1、这个没解释的就是true
        System.out.println("i=i0\t" + (i == i0));  //true
        //2、int值只要在-128和127之间的自动装箱对象都从缓存中获取的,所以为true
        System.out.println("i1=i2\t" + (i1 == i2));  //true
        //3、涉及到数字的计算,就必须先拆箱成int再做加法运算,所以不管他们的值是否在-128和127之间,只要数字一样就为true
        System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));//true  
        //比较的是对象内存地址,所以为false
        System.out.println("i4=i5\t" + (i4 == i5));  //false
        //5、同第3条解释,拆箱做加法运算,对比的是数字,所以为true
        System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));//true 
        //由于i7和i8超过了127,所以不能从缓存中直接取出,两个都需要在堆中创建不同的对象空间
        System.out.println("i7==i8"+(i7==i8));     
        //double的装箱操作没有使用缓存,每次都是new Double,所以false
        System.out.println("d1=d2\t" + (d1==d2));//false
    
    • 看到这里我们已经对自动装箱和拆箱的原理了解,现在需要解决最后一个问题自动拆箱和装箱的时机。
      当基础类型与它们的包装类有如下几种情况时,编译器会自动帮我们进行装箱或拆箱.
      进行 = 赋值操作(装箱或拆箱)
      进行+,-,*,/混合运算 (拆箱)
      进行>,<,==比较运算(拆箱)
      调用equals进行比较(装箱)
      ArrayList,HashMap等集合类 添加基础类型数据时(装箱)

    装箱带来的问题

    • 我们再来看看自动拆装箱我目前知道可能遇到的问题
      基本类型只有功能完备的值,而包装类型除了其对应的基本类型所有的功能之外,还有一个非功能值:null。
      现在来看一段简单的代码:
      static Integer i;
      public static void main(String[] args) {
        if(i == 128){
        System.out.println(“Unbelieveable~”);
        }
      }
      你认为会输出什么呢?不知道?自己运行一下~~~~
      其实这段代码并不能正确的运行,因为它会报一个NullPointException异常,为什么?因为在定义i的时候,它是Integer类的一个引用,而i没有初始化,就像所有对象引用一样,如果没有初始化那么就赋一个null值。既然现在i是一个null,那么上面已经提到,当混合使用基本类型与包装类型时,包装类会自动拆箱。现在i都没有指向任何对象,因此拆箱的时候就会报一个NullPointException异常。

    这里我们看到包装类可以允许NULL值,因为它是一个对象。而我们的基本数据类型没有NULL值,所以在我们想要从数据库的到值时候,一定要用包装类型,因为我们也不知道是否会返回一个NULL值。所以在平常使用中最好使用包装类。

    • 所有整型包装类对象之间值的比较,全部使用 equals 方法比较。
      在我们的Java开发手册中写到**“所有整型包装类对象之间值的比较,全部使用 equals 方法比较。”**
      说明:对于 Integer var = ? 在-128 至 127 之间的赋值,Integer 对象是在 IntegerCache.cache 产生,会复用已有对象,这个区间内的 Integer 值可以直接使用==进行判断,但是这个区间之外的所有数据,都会在堆上产生,并不会复用已有对象,这是一个大坑,推荐使用 equals 方法进行判断。
      这里我们不做多的解释了,相信看了上面的到这里我们已经知道为什么了!
    展开全文
  • nosql数据库有哪些 有多种针对移动平台(例如iOS和Android)的NoSQL解决方案。 在这里,我们将研究Couchbase Lite (CBL – TouchDB的后继产品),这是一个轻量级的,功能齐全的嵌入式JSON数据库。 为什么要使用功能...
    nosql数据库有哪些

    nosql数据库有哪些

    有多种针对移动平台(例如iOS和Android)的NoSQL解决方案。 在这里,我们将研究Couchbase Lite (CBL – TouchDB的后继产品),这是一个轻量级的,功能齐全的嵌入式JSON数据库。

    为什么要使用功能全面的数据库,而不仅仅是云服务的包装器? 基本上是响应能力 这个想法是,即使网络中断或速度很慢,该应用程序也应始终对用户可用。 当然,能够在本地处理数据也意味着我们必须在某个时候与服务器同步

    请注意,尽管有“ Couch”部分,但CBLApache CouchDB有很大不同

    现在,让我们开始做生意,创建一个小型Android应用程序(整个代码在GitHub可用),该应用程序使用CBL的Native API设置数据库,并运行基本的CRUD操作。

    在完成了相对简单的设置之后( 是针对老Eclipse用户的, 那是针对Android Studio爱好者的),让我们从编写一些代码开始:

    import com.couchbase.lite.*;
    import com.couchbase.lite.android.AndroidContext;
    
    /** Database wrapper*/
    public class CbDatabase {
    
      private Database database;
      private Manager manager;
    
      /** Ctor Setup */
      public CbDatabase(String dbname) 
                        throws IOException, CouchbaseLiteException {
          
         // 1. use default settings (read/write access)
         manager = new Manager( new AndroidContext(ctx),  
                                Manager.DEFAULT_OPTIONS );
    
         // 2. Check database name given by user
         // No upper case allowed in CBL!
         // Only the following characters are valid: 
         // abcdefghijklmnopqrstuvwxyz0123456789_$()+-/
    
         if ( ! Manager.isValidDatabaseName(dbname)) {
             // report...
             return;
         }	
         // 3. Get existing db with that name
         // or create a new one if it doesn't exist
          database = manager.getDatabase(dbname);
      }
    
      //...more methods to come
    }

    上面的代码使用Manager来设置具有有效名称的数据库。 CBL数据库基本上是文档的容器。 管理器可以创建几个不同的数据库,每个数据库都有自己的名称空间。 以下是释放所有资源的方法:

    /** */
    public void close(){
      if(manager != null){
        manager.close();
      }
    }

    一旦给了数据库对象,我们就可以对它进行CRUD操作了:

    /** C-rud */
    public String create( Map<String, Object> docContent )
                           throws CouchbaseLiteException {
    
      // create an empty document
      Document doc = database.createDocument();
      // add content to document and save it
      doc.putProperties(docContent);
      return doc.getId();
    }

    CBL 文档是存储在数据库中的主要实体,并具有以下属性:

    • 可以自动生成为UUID的唯一ID(_id属性)
    • 修订ID(_rev属性)以跟踪更新
    • 一组构成文档主体的键/值对

    创建完成后,我们可以通过其ID检索文档的内容:

    /** c-R-ud */
    public Map<String, Object> retrieve(String docId){
      return database.getDocument(docId)
             .getProperties();
    }

    我们可以使用回调更新文档中现有的键/值对条目:

    /** cr-U-d (auto-retry) */
    public void update( final String key, final Object value, 
                        String docId )
                        throws CouchbaseLiteException {
    
       // retrieve the document from the database
       Document doc = database.getDocument(docId);
       doc.update(new Document.DocumentUpdater() {
           @Override
           /** This may be called more than once */
           public boolean update(UnsavedRevision newRevision) {
               Map<String, Object> properties = newRevision.getUserProperties();
               properties.put(key, value);
               newRevision.setUserProperties(properties);
               return true;
           }
       });
    }

    在写冲突的情况下,该方法通过重新读取Document并重新调用回调方法来自动重试更新。 该过程将一直持续到写入成功为止。 顾名思义, UnsavedRevision是可变的副本,可以使用该副本,直到最终将数据持久保存到数据库中为止。删除文档非常简单。 在这里,我们通过其ID进行操作:

    /** cru-D */
    public boolean delete(String docId)
                          throws CouchbaseLiteException {
    
       // retrieve the document from the database
       Document doc = database.getDocument(docId);
       // delete the document
       doc.delete();
       return  doc.isDeleted();
    }

    删除文档将创建一个新的修订版本,称为“墓碑”(不开玩笑)。 它将被标记为已删除,以便在进行同步时可以将其状态复制到服务器。 至于更新,如果其他用户对同一文档进行更改,则可能导致冲突。 在这种情况下,重试删除的决定留给我们。

    现在,我们准备在项目中使用此包装器类。 首先,让我们定义用例:假设我们需要在本地为我们的手机游戏存储一些用户数据,例如用户电子邮件,当用户在我们的系统中注册时以及一系列游戏得分。 这是一个快速测试,我们可以在主Activity的onCreate()方法中运行。 首先,让我们输入一些数据:

    // get the current date and time
    Date now = new Date();
    String nowString = DateFormat.getDateTimeInstance(
    DateFormat.LONG, DateFormat.LONG).format(now);
    // game scores
    List<Double> scores = new ArrayList<Double>();
    scores.add(190.00);
    scores.add(210.00);
    scores.add(250.00);
    scores.add(275.00);
    // create an object that contains data for a document
    Map<String, Object> docContent = new HashMap<String, Object>();
    docContent.put("email", "Nomad@nomad.com");
    docContent.put("registered", nowString);
    docContent.put("scores", scores);

    现在,数据库操作:

    try{
       CbDatabase db = new CbDatabase("testdb");
       // 1. Create
       String docId = db.create(docContent);
       // 2. Retrieve
       Map<String, Object> docContent = db.retrieve(docId);
       // 3. Update
       scores.add(350.00);
       db.update("scores", scores, docId);
       // 4. Delete
       boolean deleted = db.delete(docId);
       assert(deleted == true);
    } 
    catch (Exception e) {
       // handle here...
    } 
    finally{
      if(db != null){
         db.close();
      }
    }

    以下是用于检索和更新的相应JSON文档:

    // retrieved
    { 
      _rev=1-1ef4c4618a712cdf437d4b0c92594ddc, 
      _id=69fdcb83-1774-4a3f-9e88-b298d3c7304a, 
       scores=[190.0, 210.0, 250.0, 275.0], 
       email=Nomad@nomad.com, 
       registered=June 18, 2014 11:03:18 AM GMT+02:00
    }
    //--------------------------------------------
    // updated scores: note the change in revision 
    { 
      _rev=2-23e6d83d243f80c03b17c4160d511e16, 
       scores=[190.0, 210.0, 250.0, 275.0, 350.0], 
      _id=69fdcb83-1774-4a3f-9e88-b298d3c7304a, 
       email=Nomad@nomad.com, 
       registered=June 18, 2014 11:03:18 AM GMT+02:00
    }

    而已。 进一步的代码细节在GitHub上 我们只是通过这个非常基本的介绍来介绍CBL的表面。 不幸的是,与iOS相比,目前用于Android的CBL在线文档尚不完整。 无论如何,还有其他重要的CBL功能,例如添加附件,视图和查询,复制(服务器和P2P),REST API等。这些将成为以后文章的主题。

    翻译自: https://www.javacodegeeks.com/2014/06/nosql-on-android.html

    nosql数据库有哪些

    展开全文
  • 回答这个问题之前,我们先来看看报表工具到目前为止都有哪些形态,虽然国产的大部分都是 java 语言开发的,功能方面也基本相同,但是形态还是有差异的。 差异在于,有一些厂商始终把报表定位为一个通用工具类中间件...

    回答这个问题之前,我们先来看看报表工具到目前为止都有哪些形态,虽然国产的大部分都是 java 语言开发的,功能方面也基本相同,但是形态还是有差异的。

    差异在于,有一些厂商始终把报表定位为一个通用工具类中间件产品,因其特性,使得集成商与自己的产品或项目做集成时比较简便且灵活,这也是大部分集成商希望的一个定位。

    另外有些厂商,不愿意只挣工具的钱了,想把报表包装成一个通用的平台,既能挣工具的钱,又能挣一部分平台的钱,这个形态的优点是,遇上一些需求简单的终端用户可以直接拿来用;缺点是,很多项目定制程度高,统一平台基本用不了,集成商会很头疼,因为多给我一套系统,不知道该怎么部署集成了,具体后面再说。

    了解了产品形态,接下来我们再来看看报表工具有哪些部署方式。概括起来也是两种:集成部署与独立部署,先解释下两种模式:

    集成部署是把报表嵌入已有系统,以模块形式存在,统一使用系统的登录、组织架构、权限等平台功能。集成部署细分的话,又包括两种情况:深入集成、报表作为服务集成。

    其中深入集成是把报表和已有系统放到一块儿,物理上就在一个应用里。

    imagepng

    而服务式的集成,则将报表和已有系统分离,各自部署,物理上是两个(或多个)应用,报表提供服务接口(一般就是 url)被其他系统集成调用,通俗点儿说就是在其他系统挂报表的链接。

    作为服务集成,实际就涉及到报表工具独立部署方式了。独立部署从字面意思也可以看出 **,** 报表与其他应用是分离的,各自独立、分别部署、本身互不干扰,如果需要调用其资源,则采用跨系统挂链接调用的方式。

    imagepng

    那么,上面的两大类报表工具,适用哪种部署方式呢?

    定位为中间件的适合无缝集成,因为他们的定位就是面向开发的集成商用户被集成,不论做产品还是项目,都可以把报表嵌入进系统。

    优点很明显,如同一颗钉子,钉到哪块儿木板上,就属于该木头板儿了,作为一个整体不分离,统一管理维护。另外,集成也比较简捷,以 java 类产品为例,基本都是复制一些 jar 文件,再放置或合并一些配置文件,就完成了。

    唯独有个缺点,必须要求报表和已有系统开发语言一致。

    中间件产品不能作为报表服务调用吗?其实也不是,部分厂商也为客户考虑到这一点,除提供中间件报表工具外,也会带一个简易的报表平台,不作为卖点,免费使用,甚至开源,便于用户快速开发。

    而做成平台的报表基本上只能独立部署,因为此类产品基本不提供模块拆分集成的模式(即便个别提供,也会作为定制服务收取昂贵的费用),自己“拆”这个活儿也是很麻烦的,估计也拆不明白。

    优点在文章开始已经提到,能快速拥有一套完整的系统,尤其是需求简单的终端用户比较喜欢,产品呈现出来也显得功能更多、更炫。

    但是,这类产品独立部署独立使用是最好的,一旦涉及跨系统调用,几乎都需要适配统一认证、组织架构同步、权限同步等,这个工作很费精力,一般情况下就是提供一堆接口自行实现,对于集成商来说,集成反而整的焦头烂额。

    总结来说,不同产品有不同的适配场景,当我们选择时,要根据自己是啥情况然后确定要啥,如果是中间件需求,就不要要求平台功能,那都是多余的,嵌入集成时反而是累赘。如果是完整系统需求,则不用考虑嵌入集成性,更应从系统整体考虑,可选择完善的平台或基于开源平台改造。

    对进一步报表和 BI 技术感兴趣的同学还可以搜索“乾学院”,上面有整套的免费“商业智能”技术课程,. 或者直接点下面的链接也可以 :
    http://www.raqsoft.com.cn/wx/course-Business-Intelligence.html

    展开全文
  • ------- android培训、java培训、期待与您交流! ---------- 1.String类功能及常见概述 2.StringBuffer 3.基本数据类型对象包装类 ...常见的操作有哪些? "abcd" 1,获取。 1.1 字符串中的包含的字符
  • 二、有哪些包装基本数据类型有八种,对应的包装类也有八种,对应关系如下: 概括的说,包装类分为两种: 对象型包装类(Object直接子类):Boolean、Character 数值型包装类(Number直接子类):Integer、...
  • java包装项目 程序包是Java的基本概念,是您开始用该语言编程时偶然发现的第一件事。 作为一个初学者,您可能不太关注软件包的结构,但是随着您成为经验丰富且成熟的软件开发人员,您开始考虑可以采取哪些措施来...
  • 1.概念: java为8种基本数据类型都提供了一种对应的类,这种类叫包装类 2.作用: 基本数据类型功能简单,不具有面向...4.有哪些包装类型? byte—>Byte short–>Short int---->Integer long–>Long boolean
  • 项目包装组织

    2020-06-07 02:29:24
    程序包是Java的基本概念,是您开始用该语言编程时偶然发现的第一件事。 作为一个初学者,您可能不太在意软件包的结构,但是随着您成为经验丰富且成熟的软件开发人员,您开始思考可以采取哪些措施来提高其效率。 几...
  • 第八章课后习题

    2019-11-15 14:43:27
    Java常用类库有哪些?其基本功能是什么? Object类:Java的根类,是所有类的共同祖先 数据类型包装类:对应Java的8个基本数据类型,包装类有Byte、Short,Integer、Long、Float,Double、Character和Boolean。 字符...
  •  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  • javascript内置对象

    2016-04-12 15:51:33
    所有编程语言都具有内部(或内置的)对象来创建 语言的基本功能。内部对象是 您编写自定义代码所用语言的基础, 该代码基于您的想象实现自定义功能。JavaScript 许多 将其定义为语言的内部对象。本文介绍了一些 最...
  • 所有编程语言都具有内部(或内置的)对象来创建 语言的基本功能。内部对象是 您编写自定义代码所用语言的基础, 该代码基于您的想象实现自定义功能。JavaScript 许多 将其定义为语言的内部对象。本文介绍了一些 最...
  • 语言的基本功能。内部对象是 您编写自定义代码所用语言的基础, 该代码基于您的想象实现自定义功能。JavaScript 有许多 将其定义为语言的内部对象。本文介绍了一些 最常用的对象,并简要介绍了它们 有哪些功能以及...
  • 所有编程语言都具有内部(或内置的)对象来创建 语言的基本功能。内部对象是 您编写自定义代码所用语言的基础, 该代码基于您的想象实现自定义功能。JavaScript 许多 将其定义为语言的内部对象。本文介绍了一些 最...
  • 所有编程语言都具有内部(或内置的)对象来创建语言的基本功能。内部对象是 您编写自定义代码所用语言的基础,该代码基于您的想象实现自定义功能。JavaScript许多将其定义为语言的内部对象。本文介绍了一些最常用...
  • JavaScript内置对象

    2012-07-30 11:56:48
    所有编程语言都具有内部(或内置的)对象来创建语言的基本功能。内部对象是 您编写自定义代码所用语言的基础, 该代码基于您的想象实现自定义功能。JavaScript 许多将其定义为语言的内部对象。本文介绍了一些 最...

空空如也

空空如也

1 2 3
收藏数 57
精华内容 22
关键字:

包装有哪些基本功能