精华内容
下载资源
问答
  • spring封装mongodb代码实现

    千次阅读 2016-10-10 15:57:00
    众所周知,spring集成的一些nosql或者sql数据库,都习惯用xxxxTemplate。...我一般用json格式存储,结构如下代码所示。如何查看mongodb的数据,可以使用mongoVUE工具。我们可以在Mongodb中存储数亿级别的这种数据

    众所周知,spring集成的一些nosql或者sql数据库,都习惯用xxxxTemplate。一般看到xxxxTemplate,我们就可以认为是spring集成的。要和原生的使用方式区分开来。这里,我们不讨论在java项目中原生的mongodb的使用方式,单讨论spring提供的mongodb的封装。

    在此之前,我们有必要了解下mongodb的数据存储格式。我一般用json格式存储,结构如下代码所示。如何查看mongodb的数据,可以使用mongoVUE工具。我们可以在Mongodb中存储数亿级别的这种数据而不影响效率。提醒一下:Mongodb不适合按照多条件查询,我们一般用id值来做查询。多条件查询时需要建索引,而且容易把库查死。

    {
      "_id" : "123456789",
      "_class" : "com.OrderInfo",
      "historyId" : "123456789_1_2",
      "orderId" : NumberLong("123456789"),
      "orderDirection" : "正向",
      "overStatus" : "已完成",
      "orgArea" : "华北",
      "org" : "总公司",
      "orderType" : "一般订单",
      "paymentType" : "货到付款",
      "paymentTpyeGroup" : "后款",
      "orderPrice" : 0.0,
      "duePrice" : 0.0,
      "payPrice" : 1000.0,
      "tuiKuanPrice" : 0.0,
      "diffPrice" : -1000.0,
      "memberId" : "testlzg",
      "laiyuan" : "站点",
      "invoicePutType" : "未开票",
      "operationTime" : "20190104160726",
      "status" : "完成",
      "carrier" : "测试操作单位",
      "ttsj" : "20190104160726",
      "waybillSign" : "300000000000000",
      "operateNodeSystem" : "站点-妥投",
      "bizNodeType" : "站点",
      "bizNodeName" : "测试操作单位",
      "bizNodeCode" : "910",
      "belongSystem" : "TMS",
      "systemCode" : "josl",
      "operater" : "张三",
      "operaterErp" : "1122",
      "distributeType" : "65",
      "endDate" : "20190104160726",
      "validTag" : "1",
      "orderStatus" : "暂停",
      "duizhangStatus" : "足额对账",
      "updateTime" : ISODate("2016-10-10T03:16:52.068Z"),
      "orgId" : "6",
      "createTime" : "20161010111636",
      "damagedPrice" : 0.0,
      "tmplateNode" : "妥投"
    }

    要想在spring程序中使用mongodb,我们应该怎么做呢。

    首先:

    引入mongodb的jar包

    <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-mongodb</artifactId>
    </dependency>
    
    当然,如果不使用maven,你有可以单独直接下载spring-data-mongodb-1.3.3.jar引入到你的项目中。

    其次:

    需要在我们的spring的配置文件中增加Mongodb的配置。

    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
    	xsi:schemaLocation="http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context-3.0.xsd
              http://www.springframework.org/schema/data/mongo
              http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
              http://www.springframework.org/schema/beans
              http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    
        <mongo:mongo id="mongo_Test" replica-set="ip1:port1,ip2:port2"><!--配置mongodb服务器和端口,这里是基于复制级的,可以配置一主多从-->
    
        <mongo:options connections-per-host="100"
                           threads-allowed-to-block-for-connection-multiplier="4"
                           connect-timeout="2000"
                           max-wait-time="3000"
                           auto-connect-retry="true"
                           socket-keep-alive="true"
                           socket-timeout="10000"
                           slave-ok="true"
                           write-number="1"
                           write-timeout="0"
                           write-fsync="false"/> <!--控制数据写的时候,是否刷新完磁盘返回-->
        </mongo:mongo>
    
        <mongo:db-factory id="mongoDbFactoryPrism" dbname="dbname" username="username" password="${password}" mongo-ref="mongo_Test"/>
    
        <bean id="mongoTemplateTest" class="org.springframework.data.mongodb.core.MongoTemplate">
            <constructor-arg name="mongoDbFactory" ref="<span style="font-family: Arial, Helvetica, sans-serif;">mongoDbFactoryPrism</span><span style="font-family: Arial, Helvetica, sans-serif;">" /></span>
    	  <property name="writeResultChecking" value="EXCEPTION" /><!--控制mongodb是否抛异常-->
    	  <property name="writeConcern" value="SAFE" /><!--控制mongodb的安全级别-->
        </bean>
        <bean id="mongoDBCache" class="com..MongoDBCacheImpl">
            <property name="mongoOperations" ref="mongoTemplateTest"/>
        </bean>
    </beans>

    这种配置是不是一目了然呢。spring中好多封装配置也就这样,一环扣一环,最后给我们一个可以用的手把,例如 mongoDBCache。


    最后:

    我们就可以通过实现我们的MongoDBCacheImpl来写我们的业务逻辑了。

    public class MongoDBCacheImpl {
    
        public void setMongoOperations(MongoOperations mongoOperations) {
            this.mongoOperations = mongoOperations;
        }
    
        private MongoOperations mongoOperations;
    //根据key获取
        public <T> T getByKey(Object key, Class<T> entityClass) {
            return mongoOperations.findById(key, entityClass);
        }
    
        public <T> List<T> getByColumn(String columnName, Object columeValue, Class<T> entityClass) {
            return mongoOperations.find(new Query(Criteria.where(columnName).is(columeValue)), entityClass);
        }
    //保存
        public void save(Object obj) {
            mongoOperations.save(obj);
        }
    //移除
        public void remove(Object obj) {
            mongoOperations.remove(obj);
        }
    
        public <T> Long getCountByDate(Date beginTime, Date endTime, Class<T> entityClass) {
    
            Assert.notNull(beginTime, "beginTime is not null.");
            Assert.notNull(endTime, "endTime is not null.");
            Assert.isTrue(endTime.after(beginTime), "endTime must be after beginTime.");
    
            return mongoOperations.count(new Query(Criteria.where("createdate").gte(beginTime).and("createdate").lt(endTime)), entityClass);
    
        }
    
        public <T> List<T> findAllByDate(Date beginTime, Date endTime, Class<T> entityClass) {
            Assert.notNull(beginTime, "beginTime is not null.");
            Assert.notNull(endTime, "endTime is not null.");
            Assert.isTrue(endTime.after(beginTime), "endTime must be after beginTime.");
    
            Query query = new Query().addCriteria(
                    Criteria.where("riqi").exists(true)
                            .andOperator(Criteria.where("riqi").gte(beginTime),Criteria.where("riqi").lt(endTime)));
            return mongoOperations.find(query, entityClass);
    
        }
    
        public <T> List<T> findAllByDateAndColumn(String dateColumnName, Date beginTime, Date endTime, String columnName, Object columeValue, Class<T> entityClass) {
    
            Query query = new Query().addCriteria(
                    Criteria.where(dateColumnName).exists(true)
                            .andOperator(Criteria.where(dateColumnName).gte(beginTime),Criteria.where(dateColumnName).lt(endTime))
                            .and(columnName).is(columeValue));
            return mongoOperations.find(query, entityClass);
        }
        
    //统计
        public <T> Long  getCountByDateAndColumn(String dateColumnName, Date beginTime, Date endTime, String columnName, Object columeValue, Class<T> entityClass) {
    
            Query query = new Query().addCriteria(
                    Criteria.where(dateColumnName).exists(true)
                            .andOperator(Criteria.where(dateColumnName).gte(beginTime),Criteria.where(dateColumnName).lt(endTime))
                            .and(columnName).is(columeValue));
    
            return mongoOperations.count(query,entityClass);
        }
    //分页查询
        public <T> Pagination<T> getPageListByDateColumn(String dateColumnName, Date beginTime, Date endTime, Pagination<T> page, Class<T> entityClass) {
            Query query = new Query().addCriteria(
                    Criteria.where(dateColumnName).exists(true)
                            .andOperator(Criteria.where(dateColumnName).gte(beginTime),Criteria.where(dateColumnName).lte(endTime)));
            if (null != page && page.getTotalCount()>0){
    
                    page.setTotalCount(page.getTotalCount());
                    query.skip(page.getFirstResult());
                    query.limit(page.getPageSize());
    
            }else {
    
                return null;
            }
    
            List<T> pageData = mongoOperations.find(query,entityClass);
            page.setDatas(pageData);
    
            return page;
        }
    //按照Key更新
        public <T> void updateByKey(Object key, String updateColumn, Object value, Class<T> entityClass) {
            Query query = new Query(Criteria.where( "_id" ).is(key));
            mongoOperations.updateFirst(query,Update.update(updateColumn,value),entityClass);
        }
    //删除指定key
        public <T> void deleteByKey(Object key, Class<T> entityClass) {
            Query query = new Query(Criteria.where( "_id" ).is(key));
            mongoOperations.remove(query,entityClass);
        }
    //删除所有
        public <T> void removeAll(String dateColumnName, Date beginTime, Date endTime, String columnName, Object columeValue, Class<T> entityClass){
            Query query = new Query().addCriteria(
                    Criteria.where(dateColumnName).exists(true)
                            .andOperator(Criteria.where(dateColumnName).gte(beginTime),Criteria.where(dateColumnName).lte(endTime))
                            .and(columnName).is(columeValue));
            mongoOperations.remove(query,entityClass);
        }
    
    }
    


    至此,我们就可以用mongodb对我们的数据进行增删改查了,对于复制级的mongodb,数据量在3亿以上,更新查询操作也一般在5ms之内。


    展开全文
  • MongoDB 测试 Python 代码

    2017-11-07 14:32:09
    随机数查询测试 MongoDB 的 Python 代码写库程序#!/usr/bin/env pythonfrom pymongo import Connection import time import datetimeconnection = Connection('127.0.0.1', 27017) db = connection['hawaii']#时间...

    随机数查询测试 MongoDB 的 Python 代码

    写库程序

    #!/usr/bin/env python
    
    from pymongo import Connection
    import time
    import datetime
    
    connection = Connection('127.0.0.1', 27017)
    db = connection['hawaii']
    
    #时间记录器
    def func_time(func):
    
        def _wrapper(*args,**kwargs):
    
            start = time.time()
            func(*args,**kwargs)
            print func.name,'run:',time.time()-start
        return _wrapper
    
    @func_time
    def insert(num):
    
        posts = db.userinfo
    
        for x in range(num):
    
            post = {"_id" : str(x),
                    "author": str(x)+"Mike",
                    "text": "My first blog post!",
                    "tags": ["mongodb", "python", "pymongo"],
                    "date": datetime.datetime.utcnow()}
    
            posts.insert(post)
    
    
    if name == "main":
    
        #设定循环500万次
        num = 5000000
        insert(num)
    

    查询程序

    #!/usr/bin/env python
    
    from pymongo import Connection
    import time
    import datetime
    import random
    
    connection = Connection('127.0.0.1', 27017)
    db = connection['hawaii']
    
    def func_time(func):
    
        def _wrapper(*args,**kwargs):
            start = time.time()
            func(*args,**kwargs)
            print func.name,'run:',time.time()-start
        return _wrapper
    
    #@func_time
    def randy():
    
        rand = random.randint(1,5000000)
        return rand
    
    @func_time
    def mread(num):
    
        find = db.userinfo
        for i in range(num):
            rand = randy()
            #随机数查询
            find.find( {"author": str(rand)+"Mike"} )
    
    
    if name == "main":
    
        #设定循环100万次
        num = 1000000
        mread(num)
    

    删除程序

    #!/usr/bin/env python
    
    from pymongo import Connection
    import time
    import datetime
    
    connection = Connection('127.0.0.1', 27017)
    db = connection['hawaii']
    
    def func_time(func):
    
        def _wrapper(*args,**kwargs):
    
            start = time.time()
            func(*args,**kwargs)
            print func.name,'run:',time.time()-start
    
        return _wrapper
    
    @func_time
    def remove():
    
        posts = db.userinfo
        print 'count before remove:',posts.count();
        posts.remove({});
        print 'count after remove:',posts.count();
    
    if name == "main":
        remove()
    
    展开全文
  • 我的第一个Ruby On Rails + MongoDB程序

    千次阅读 2011-10-20 08:02:16
    最近想进一步学习一下MongoDB,而很久之前使用过ROR,正好也凑个机会重新拾起来。下面是建立第一个项目的过程。 主要参考文档: 1. Rails 3 - Getting started 2. MongoDB and MongoMapper (可能需要翻墙) 3....

        最近想进一步学习一下MongoDB,而很久之前使用过ROR,正好也凑个机会重新拾起来。下面是建立第一个项目的过程。

           主要参考文档:

           1. Rails 3 - Getting started

           2. MongoDB and MongoMapper (可能需要翻墙)

           3. Getting started with VMware CloudFoundry, MongoDB and Rails (可能需要翻墙)

    一、创建程序的框架

    创建项目时不再使用rails active_record支持:

    $ rails new todo -O

    依次完成文档1中的所提示的步骤。

    1. 编辑GemFile,增加下面的内容:

    source "http://gemcutter.org"
    
    gem "mongo_mapper"
    
    
    2. 执行

    $ bundle install

    安装项目的依赖包

    3. 在config/initializer下面新建一个mongo.rb文件,指定全局的数据库信息:

    MongoMapper.connection = Mongo::Connection.new('localhost', 27017)
    MongoMapper.database = 'todo' #为了简单起见,没有为不同的环境指定不同的数据
    
    if defined?(PhusionPassenger)
       PhusionPassenger.on_event(:starting_worker_process) do |forked|
         MongoMapper.connection.connect if forked
       end
    end

    4. 在lib目录下面新建一个mongo.rake文件(在本文中还没有用到)

    namespace :db do
      namespace :test do
        task :prepare do
          # Stub out for MongoDB
        end
      end
    end

    完成以上步骤后,启动程序:

    $ rails server
    
    **Notice: C extension not loaded. This is required for optimum MongoDB Ruby driver performance.
      You can install the extension as follows:
      gem install bson_ext
    
      If you continue to receive this message after installing, make sure that the
      bson_ext gem is in your load path and that the bson_ext and mongo gems are of the same version.
    
    => Booting WEBrick
    => Rails 3.0.10 application starting in development on http://0.0.0.0:3000
    => Call with -d to detach
    => Ctrl-C to shutdown server
    [2011-10-19 23:36:14] INFO  WEBrick 1.3.1
    [2011-10-19 23:36:14] INFO  ruby 1.9.2 (2011-07-09) [x86_64-linux]
    [2011-10-19 23:36:14] INFO  WEBrick::HTTPServer#start: pid=19595 port=3000

    从上面输出中可以看到bson_ext库没有加载。首先按照提示安装该库:

    sudo gem install bson_ext

    然后编辑GemFile,加入下面一行:

    gem "bson_ext"

    再次启动程序,Notice提示消息消失,启动正常。在浏览器输入:http://127.0.0.1:3000,就可以看到如下页面:



    二、添加页面和处理逻辑

    通过rails的generate命令来生成页面、控制器和模型层文件:

    $ rails generate scaffold project name:string --orm=mongo_mapper

    命令执行完毕后,重新启动服务器,在浏览器输入中:http://127.0.0.1/projects,就可以看到如下:



    点击New Project链接,添加一个新项目:


    输入项目名称后,点击Create Project按钮保存

    点击Back链接回到列表页面,可以看到新创建的项目blog,已经在列表里了:


    登录到MongoDB数据库中可以查询到刚刚插入的数据:



    到现在为止还没有写一行代码。不过先到这里吧,以后接着续。




    展开全文
  • MongoDB程序数据源 由于写了程序数据源之后,是要放到报表设计器目录下进行报表设计才能看到结果的,这样给调试带来了一些难度。 解决办法就是: - main方法进行跟踪调试; - 单元测试; // 数据...

    帆软报表控件

    这里写图片描述

    官方嵌入式部署流程

    嵌入式部署流程

    拷贝文件

    • 简单粗暴式的话,直接将相关目录全部拷贝到自己项目的WEB-INF目录下;看了一下,差不多有两三百兆的样子;
    • 精细化操作的话,选择性拷贝;
    • 拷贝的jar包包括6个fr的jar包,1个fr的plugin的jar包;(与官方文档有不相符的地方);
    • 拷贝的目录包括plugins目录(报表控件的插件目录),reportlets目录(将来存放报表的目录),resources目录(资源文件目录);

    web.xml配置

    在项目的web.xml中配置报表控件的servlet及servlet-mapping。

    部署过程遇到的问题

    • 组内的项目是Maven项目,是通过pom.xml管理项目的jar包依赖的,也就是没有在项目目录下保留lib目录;这样就导致报表控件所需的jar包无法直接拷贝到程序目录下,而创建lib的话与maven项目会有所冲突;
    • 目录拷贝的选择性;帆软官方文档让把reportlets、resources、plugins目录完整拷贝到项目目录下。查看了一下对应目录,reportlets目录下有很多的演示报表cpt文件,plugins是安装的插件文件,resources下面有很多配置文件以及地图文件……
    • 项目使用SpringMVC,直接使用前置的Dispatcher进行所有请求的分发;这样的话,报表控件的servlet就会被忽略掉;
    • ……

    部署问题处理

    • 关于项目依赖jar包的处理,采用的方式是搭建maven私服,使用的是nexus;这样仅需要在组内项目中配置maven仓库地址即可,对项目的冲击最小。(在Nexus中进行第三方jar包的管理);
    • 从报表控件要拷贝的目录中删除项目不需要的文件,reportlets下的示例报表全部清理掉,plugins下目前仅保留与web页面自适应相关的插件,resources目录下把地图相关的资源全部清理掉,别的配置文件目前没有深究暂且保留;
    • 在web.xml中目前先把报表控件的ReportServer的servlet前置,后面再研究相关的处理吧;

    程序数据源

    之所以要用到程序数据源,是因为组内的项目使用的数据库是mongodb,而帆软的mongodb插件支持的查询深度还不够,所以采用程序数据源的方式来处理。
    帆软报表控件程序数据源的写法说白了比较简单,就是实现AbstractTableData这个抽象类,然后实现其中的4个抽象方法即可。
    但是使用起来不是很顺畅,原因在于:
    - 首先要在在IDE中写程序数据源的代码;
    - 然后编译对应的代码生成class文件;
    - 将class文件拷贝到帆软报表设计器对应的classes目录下;
    - 打开报表设计器选择程序数据源(class文件)进行报表设计;
    - 设计完成的报表拷贝到项目的reportlets目录下;
    可以看到,需要不停地在IDE和报表设计器之间切换,还需要在资源管理器中移动文件。可能这是目前嵌入式部署不得不面对的问题,如果是独立部署的话,可能就仅仅需要将classes文件拷贝到帆软报表设计器对应目录下即可。

    测试程序数据源可行性

    在项目中写了一个数据源,如下:

    public class TestDemo extends AbstractTableData {
    
        private String[] columnNames;
        private Object[][] rowData;
    
        public TestDemo() {
            String[] columnNames = {"Name", "Score"};
            Object[][] datas = {{"Alex", new Integer(15)}, {"Helly", new Integer(22)}, {"Bobby", new Integer(99)}};
            this.columnNames = columnNames;
            this.rowData = datas;
        }
    
        @Override
        public int getColumnCount() throws TableDataException {
            return columnNames.length;
        }
    
        @Override
        public String getColumnName(int columnIndex) throws TableDataException {
            return columnNames[columnIndex];
        }
    
        @Override
        public int getRowCount() throws TableDataException {
            return rowData.length;
        }
    
        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            return rowData[rowIndex][columnIndex];
        }
    }

    不涉及业务,不涉及mongodb数据库,仅仅测试一下可行性。
    按照上面的步骤设计完报表之后,将报表拷贝回项目reportlets目录,运行:
    这里写图片描述
    可以看到,程序运行OK,报表也能正常显示。

    MongoDB程序数据源

    由于写了程序数据源之后,是要放到报表设计器目录下进行报表设计才能看到结果的,这样给调试带来了一些难度。
    解决办法就是:
    - main方法进行跟踪调试;
    - 单元测试;

        // 数据源一共有多少列(多少个字段)
        public abstract int getColumnCount() throws TableDataException;
    
        // 对应index的那一列的列名(字段名)是什么
        public abstract String getColumnName(int index) throws TableDataException;
    
        // 数据源一共有多少行(多少条记录)
        public abstract int getRowCount() throws TableDataException;
    
        // 对应rowIndex的那一行的第columnIndex列的数值
        public abstract Object getValueAt(int rowIndex, int columnIndex);

    从抽象类接口可以看出,四个抽象方法意义很明确,使用main方法或者单元测试来进行验证的话,跟踪调试查看的数据没有问题,那么报表中的数据应该就没有问题。

    关于数据库连接的问题

    按照从前的思维,希望能够使用数据库连接池,复用数据库连接。
    然后发现MongoDB的MongoClient和关系型数据库的连接还是有一些区别的,可能开销没有那么大。因此在数据源中直接new新的MongoClient来使用。
    再后来仔细想想,我们的程序数据源不是运行在我们的Web容器中,不是使用Spring进行管理,而是编译成为class文件之后拷贝到帆软的设计器目录下使用的,那个时候,怎么使用数据库连接池中的连接资源呢?
    所以,目前还是在每个数据源中直接new连接的方式来操作,有没有更好的办法抽空问问帆软的技术支持。

    数据源Demo

    按照业务,从我们自己的mongo数据库中获取数据,写了如下一个数据源:

    public class BQItemDataSource extends AbstractTableData {
    
        private enum Field_Name {
            CODE("code"), DESCRIPTION("description"), SPEC("spec"), UNIT("unit"), JLGZ("jlgz"),
            TYPE("type"), QUANTITY("quantity");
    
            private String fieldName;
    
            private Field_Name(String fieldName) {
                this.fieldName = fieldName;
            }
    
            @Override
            public String toString() {
                return fieldName;
            }
        }
    
        private String[] columnNames;
        private ArrayList<LinkedHashMap<String, Object>> rowData;
    
        public BQItemDataSource() {
    //        setDefaultParameters(new Parameter[] {new Parameter("ObjectId")});
            columnNames = new String[Field_Name.values().length];
            int i = 0;
            for (Field_Name fieldName : Field_Name.values()) {
                columnNames[i++] = fieldName.toString();
            }
        }
    
        @Override
        public int getColumnCount() throws TableDataException {
            return columnNames.length;
        }
    
        @Override
        public String getColumnName(int columnIndex) throws TableDataException {
            return columnNames[columnIndex];
        }
    
        @Override
        public int getRowCount() throws TableDataException {
            init();
            return rowData.size();
        }
    
        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            init();
            if (columnIndex >= columnNames.length) {
                return null;
            }
            if (rowIndex >= rowData.size()) {
                return null;
            }
    
            return rowData.get(rowIndex).get(columnNames[columnIndex]);
        }
    
        public void init() {
            if (rowData != null) {
                return;
            }
    
            rowData = new ArrayList<LinkedHashMap<String, Object>>();
    //        String objectId = parameters[0].getValue().toString();
            String objectId = "5959b01b9107541bbc5cb98b";
            JSONArray dataArray = getMongoTableData();
            for (int i = 0; i < dataArray.size(); i++) {
                JSONObject dataObj = dataArray.getJSONObject(i);
                LinkedHashMap<String, Object> row = new LinkedHashMap<String, Object>();
                if (dataObj.containsKey(Field_Name.CODE.toString())) {
                    row.put(Field_Name.CODE.toString(), dataObj.getString(Field_Name.CODE.toString()));
                } else {
                    row.put(Field_Name.CODE.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.DESCRIPTION.toString())) {
                    row.put(Field_Name.DESCRIPTION.toString(), dataObj.getString(Field_Name.DESCRIPTION.toString()));
                } else {
                    row.put(Field_Name.DESCRIPTION.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.SPEC.toString())) {
                    row.put(Field_Name.SPEC.toString(), dataObj.getString(Field_Name.SPEC.toString()));
                } else {
                    row.put(Field_Name.SPEC.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.UNIT.toString())) {
                    row.put(Field_Name.UNIT.toString(), dataObj.getString(Field_Name.UNIT.toString()));
                } else {
                    row.put(Field_Name.UNIT.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.JLGZ.toString())) {
                    row.put(Field_Name.JLGZ.toString(), dataObj.getString(Field_Name.JLGZ.toString()));
                } else {
                    row.put(Field_Name.JLGZ.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.TYPE.toString())) {
                    row.put(Field_Name.TYPE.toString(), dataObj.getString(Field_Name.TYPE.toString()));
                } else {
                    row.put(Field_Name.TYPE.toString(), null);
                }
                if (dataObj.containsKey(Field_Name.QUANTITY.toString())) {
                    row.put(Field_Name.QUANTITY.toString(), dataObj.getDouble(Field_Name.QUANTITY.toString()));
                } else {
                    row.put(Field_Name.QUANTITY.toString(), null);
                }
                rowData.add(row);
            }
        }
    
        private JSONArray getMongoTableData() {
            MongoClient mongoClient=new MongoClient( "localhost" , 27017 );
            MongoDatabase db = mongoClient.getDatabase("gbq");
            MongoCollection<Document> collection = db.getCollection("project");
            Document doc= collection.find(eq("_id", new ObjectId("5959b01b9107541bbc5cb98b"))).first();
            if(doc!=null){
                JSONObject data = JSONObject.fromObject(doc.get("data"));
                return data.getJSONArray("bqItem");
            }else{
                return new JSONArray();
            }
        }
    
        public void release() throws Exception {
            super.release();
            this.rowData = null;
        }
    
    //    public static void main(String args[]) {
    //        BQItemDataSource dataSource = new BQItemDataSource();
    //        dataSource.init();
    //        try {
    //            System.out.println(dataSource.getColumnCount());
    //            for (int i = 0; i < dataSource.getColumnCount(); i++) {
    //                System.out.println(dataSource.getColumnName(i));
    //            }
    //            for (int i = 0; i < dataSource.getRowCount(); i++) {
    //                for (int j = 0; j < dataSource.getColumnCount(); j++) {
    //                    System.out.print(dataSource.getValueAt(i, j) + "@");
    //                }
    //                System.out.println();
    //            }
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    //    }
    }

    如上的数据源中,没有使用传参方式,而是直接在代码中把参数写死了。实际上可以采用传参的方式,在帆软报表设计器中可以设定参数。
    但是,上面的数据源class拷贝到帆软设计器目录下的时候,字段是可以获取到的,但是数据是获取不到的。
    这里写图片描述
    预览报表的时候页面是空的。

    依赖的问题

    想了很久,没有得到答案。周末的时候突然灵光一闪,想到一个可能的原因:
    - 我们的程序数据源中使用了JSON和MongoClient,这两个东西是依赖于某些jar包的;
    - 程序数据源的class文件拷贝到帆软目录下,在帆软的内置服务器中运行,而这个内置服务器未必引用了对应的jar包;
    - 那为什么这个class数据源还是可以引用,并且能看到字段呢?因为帆软中引用的是class文件,而不是源代码,用到字段的时候调用getColumnCount和getColumnName这两个方法,是不受影响的;而显示数据的时候,调用getRowCount和getValueAt两个方法,内部使用了JSON和MongoClient相关的接口,可能内部已经报异常了。
    解决办法:
    - 查看程序数据源的jar包依赖(使用IDEA的Maven插件查看依赖关系图):
    这里写图片描述
    - 将所依赖的jar包拷贝到帆软的lib目录下:
    从上图可以看出,直接依赖的包有json-lib和mongodb-driver;
    因mongdodb而间接依赖的包有mongodb-driver-core和bson;
    因json而间接依赖的包有commons-beanutils、commons-logging、commons-lang、commons-collections、ezmorph。
    完成以上步骤之后,在帆软报表设计器中设计完报表点击预览,可以看到报表的内容:
    这里写图片描述
    至此,程序数据源的路已经走通,可以尽情发挥业务编程能力,编写数据源了!

    展开全文
  • 我一直致力于寻找更好的答案。首先,我制定了《服务器发现与监控规范...随后,我开发了一种被称为“黑管测试”(BlackPipeTesting)的技术,这样Ian就可以检测他的代码在与MongoDB交互时,如何应对网络故障、指令
  • 什么是MongoDB ? MongoDB 是由C++语言编写的,是一个基于分布式文件存储的开源数据库系统。 MongoDB 可在高负载的情况下,添加更多的节点,可以保证服务器性能。 MongoDB 可为Web应用提供可扩展的高性能数据存储...
  • MongoDB

    千次阅读 2020-01-21 15:13:05
    MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。 MongoDB 是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像...
  • MongoDB 通过 Java 代码 批量操作

    千次阅读 2018-09-17 17:00:01
    本文承接《MongoDB 通过 Java 代码 CRUD 文档》 Bulk操作 MongoDB提供了一种称为 BulkWrite(块)操作方式,数据不会被立即被持久化到数据库中,而是等待程序调度,确定合适的时间持久化到数据库中,其实就是批量...
  • MongoDB Go驱动程序教程第1部分:连接,使用BSON和CRUD操作 官方的MongoDB Go驱动程序随着版本1.0.0的发布而 。 现在,它已被视为功能完整且可以投入生产使用。 本教程将帮助您开始使用 。 您将创建一个简单的程序并...
  • 上一篇介绍了如何在Eclipse里面集成Cloud Foundry部署的环境,这里我用一个简单的例子... 示例源代码下载地址: https://github.com/SpringSource/cloudfoundry-samples/tree/master/hello-spring-mongodb  下载好源
  • 基于java的mongodb实例,包括与数据库连接,在程序中环境的搭建,和通过java操控数据库。解压后直接导入程序即可,自己写的代码,比较糙,但是功能都ok
  • mongodb-java-examples 如何使用 java MongoDB 驱动程序的简单示例 本项目中的所有代码示例均可免费使用。 本项目中的 MongoDB 聚合示例是 10Gen 教授的 M101J 课程中的 shell 查询的翻译。
  • 节点应用程序 带有 Express 和 MongoDB 的 NodeJS 应用程序代码结构
  • Qmgo-Go的MongoDB驱动程序。...Qmgo是从mgo迁移到新的MongoDB驱动程序且只需很少的代码更改的首选。 要求-1.10及更高版本。 -MongoDB 2.6及更高版本。 安装推荐的方法是使用go mod通过导入github.com/q自动安装依赖项
  • AsyncOptics是Node.js和Mongodb应用程序的异步代码查看器,性能监视器和程序包监视器。 它能够使用Node.js的异步挂钩和Perf挂钩来跟踪和监视异步进程。 汇总的信息显示在具有异步功能分级行为的Sankey图表中,并作为...
  • Node.js的官方MongoDB驱动程序( )将连接管理留给用户-这意味着需要此样板代码连接到mongodb数据库 const { MongoClient } = require ( 'mongodb' ) ; MongoClient . connect ( 'mongodb://localhost:27017/...
  • Spring-Data-Mongodb数据库连接代码示例

    千次阅读 2017-03-13 15:03:05
    Spring-Data-Mongodb数据库连接代码示例作为一名合格的程序员,除了要考虑需求的功能性实现之外,一定还要注意程序的健壮性,同时对于有运维经验的程序员来说,还要关注程序的安全性。年前闹得沸沸扬扬的Mongodb赎金...
  • MongoDb

    2015-01-20 15:56:18
    这是MongoDB的系列学习笔记的第一篇,主要介绍什么是非关系型数据库MongoDB,如何下载,去哪儿下载,又该怎么正确的安装等一系列问题。 一、前言 最近开始学习非关系型数据库MongoDB,却在博客园上找不到...
  • Mongodb

    千次阅读 2015-09-26 13:12:54
    1.查看 mongodb的版本 cmd进入mongodb的安装目录的bin目录下输入:mongod --dbpath=d:\mongodb\db(我的mongodb是安装在D盘下的) 2.启动mongodb cmd进入mongodb的安装目录的bin目录下输入:mongod --dbpath d:/...
  • 在Heroku上自动部署的NodeJS + Express + MongoDB应用程序。 介绍 此存储库的主要目的是能够基于Heroku自动部署带有Express和NoSQL MongoDB的NodeJS应用程序。 1-福克项目 第一步,我们从存储库页面右上角的按钮创建...
  • MongoDB Atlas提供商 这是Terraform MongoDB Atlas Provider的存储库,它允许将Terraform与MongoDB的数据库即服务产品Atlas一起使用。 通过了解有关Atlas的更多信息 有关Terraform的一般信息,请访问和。 支持,...
  • mongodb

    2012-03-08 10:33:11
    上一篇文章: http://www.cnblogs.com/hoojo/archive/2011/06/01/2066426.html介绍到了在MongoDB的控制台完成...现在我们就用Java来操作MongoDB的数据。   开发环境: System:Windows IDE:eclipse、MyEcl
  • NestJS(Express + Typeorm)代码库,其中包含实际示例(CRUD,auth,高级模式等)。 目录 结构体 功能 动态导入 认证 像OAuth一样配置jwt(access-token,refresh-token) OAuth Google OAuth Facebook 转储...
  • 身份验证机制指南包含使用 MongoDB 社区版支持的每种身份验证机制的示例连接代码。 Node.js 驱动程序使用异步 Javascript API 与您的 MongoDB 集群进行通信。 异步 Javascript 允许您在不等待处理线程空闲的情况下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,160
精华内容 22,064
关键字:

mongodb程序代码