精华内容
下载资源
问答
  • 内部订单

    千次阅读 2019-04-17 11:19:42
    内部订单 2014年03月10日 20:57:44空空为道阅读数:3039更多 个人分类:ERP SAP 内部订单 PS:转自方丈 ...这种功能分类反映不同的订单类型中,其属性定义系统中处理订单的方式。SAP...

    内部订单

    2014年03月10日 20:57:44 空空为道 阅读数:3039更多

    个人分类: ERP SAP

    内部订单

     PS:转自方丈

    内部订单修改预算:KO22

    1.内部订单概念

    1.1内部订单

        内部订单用于计划、收集、监视和结算在公司内部进行的特定操作或任务。

    内部订单可用于不同的目的。这种功能分类反映在不同的订单类型中,其属性定义了在系统中处理订单的方式。SAP系统内内部定单分为两类:实际定单和统计性定单。统计性定单, 例如用项目内部订单来管理在建工程,在月末无须结转成本。

    1.2 内部订单的常规类型

    间接费用订单:费用订单用于归集特殊事件和临时项目成本的对象。费用订单主数据创建的同时可以维护结算规则,也可于费用订单结算前维护结算规则。费用订单分统计性费用订单和真实费用订单。若是统计性费用订单则不用维护订单结算规则,因为统计性费用订单只用于报表分析的用途。

    投资订单; 用于监视在固定资产生产过程中发生的成本,如建造存储设施。

    1.3 内部订单主数据

    内部订单主记录有几个不同的部分,每个中包含有带预定义字段组的标签页。可以在“自定义”中更改标签页的标题,还可以单独地将字段分配给标签页。标准的订单主记录数据布局具有下列标签

    页:

    1、分配(包含机构分配,如公司代码、业务部门、利润中心等)

    2、控制(包括订单状态信息、订单货币、统计订单指示器等)

    3、期末结算(包含计算间接费用的成本核算表单名、结算参数等)

    4、一般数据(包含申请人、责任人等)

    5、投资(在上面的示意图中没有显示。包含资产投资订单所需的参数)

    思考,订单类型如何在系统中划分?

    其中,【图】1所示是我们自定义的的内部订单类型。

     

    01

    内部订单(Tcode:KO01)

    04

    成本控制生产订单(Tcode:KKF1,只核算成本,可不建立BOM和工艺路线)

    05

    生产成本归集器(Tcode:KKF6N,通常根据生产版本建立)

    10

    PP生产订单(Tcode:CO01,要求相关产品建立有BOM和工艺路线)

    30

    维护订单(Tcode:IW31,设备维修工单)

    40

    流程订单(Tcode:COR1,流程行业的生产订单,一般要求建有配方)

     

    1.4 内部订单主要功能

    预算:按总额、年度、月度进行预算控制。还可以做别的不,当然可以,吼吼~

    计划:内部订单的费用成本计划功能可和MM模块和生产能力计划集成,用于监视

         实际成本并和实际成本对比分析,从而为管理决策者提供依据。

    辅助核算:和国产软件的辅助核算项目很像。可以通过内部订单来归集费用,如在F-02做凭证录入时候可以选择某一统计型内部订单,那么就可以查看到这个项目的费用情况。

    分析:可以随时分析内部订单的计划/实际发生额对比,各不同期间的实际/实际对比,按月/季指标分析,分析内部订单发生的行项目,对订单的未清项等进行分析 。

    项目结算:大修项目、研发项目、在建工程项目以及技措技改项目(靠,简直就和PS模块解决的问题差不多,真是物美价廉的东东,那么这个到底和PS有啥区别,别急,老方会在SAP方丈-PS七日通中讲到。

    2.后台配置

    2.1定义内部订单类型

    首先在成本控制范围下,内部订单是需要激活状态的,同时还需要对内部订单定制很多参数。

    【图】1定义结算参数文件,结算参数文件也决定了结算规则(我们会在后面讲到)。

    【图】2 定义计划参数文件。

    【图】3 定义预算参数文件。

    【图】4 定义项目类别参数文件,还记得吧,投资、费用、生产和结果分析。

    【图】5 打上这个勾,对前台来说是可以把内部订单建立时候自动切换到下达状态。

    【图】6 定义字段选择,这个就不用说了吧,和字段状态组的感觉是一样的。

    2.2定义内部订单预算参数

    通过定义预算参数文件我们可以对预算做N多的参数控制,下面详细的介绍预算参数配置。

    【图】1 Past:指可以对过去几年做预算控制。
    【图】2 Future 指可以对未来几年做预算控制,Star指预算的开始年度,如不填写默认为当前年度。

    【图】3总值控制,可以跨年度。

    【图】4年度预算控制,不可以跨年度,为什么内部订单不能做期间控制呢????

    【图】5 定义汇率类型,参考我的SAP方丈-汇率详解

    【图】6 投资管理-程序类型预算,到底做什么用的到现在老方也没搞懂,难道是和投资管理的接口???哪个大虾知道还望指点。

    【图】7 没搞懂这是啥子,默认1是自动选择的。

    【图】8 定义的小数位数,默认为2位。

    最后别忘了把预算参数文件分配给内部订单。!!!@@!¥%……

    2.3定义内部订单预算容差限制

    通过预算容差可以限制预算执行到百分比后的动作,如图中所示,预算超百分90%(不包括90%)可以1警告 2 mail 3错误提示。

     

    2.4定义分配结构

    定义分配结构,还记得这吧。前面在我的订单剖析已经讲过了。详见http://blog.vsharing.com/SAP100/A751407.html

    成本中心:可以把内部订单的要素直接结转到成本中心,如公用的折旧中心?还记得一个折旧要几个成本中心共同承担吗? 不记得,还得打屁屁~~~哎,老方手都痛了。

    内部订单:千万不要把内部订单再结算到内部订单,因为死循环,为啥?自己想想吧。

    WBS:CO-IO到WBS迁移,谁问的这个问题来的?

    网络:同上。

    获利段:PSG

    销售订单:?

    固定资产:可以把在建工程结转到FXA(固定资产),还记得AIBU吗?

    总账科目:可以把内部订单结转到某个科目。例如我们可以把在建工程的内部订单结转到在建工程科目(资产类),研发类结转到(研发支出)。我想这种做法当期作为损益月末一次性调整就是为了出具财务报表的需要。

    是不是我讲的东西你还没太看懂,没有关系,多看几遍吧。慢慢就懂了。这个东西其实就是需要多测试,没什么难的。

    2.4定义预算参数文件

    【图】1 定义订单是否能够被计算,如果统计型订单要选择3.

    【图】2还记得我们前面定义的那些东西吧,全部对应上吧。

    【图】3默认的结算类型,GL,这个做啥用,到维护结算规则的时候大家就会看到哈。OHYEAH~

    【图】4标识,100%结算还是可以按百分比结算,还是可以按权重结算等等,这个配置我们在维护结算规则的时候也会看到。

    【图】5 指定哪个东西可以结算。

    【图】6还记得最大结算规则,别说你忘了,打屁屁的。

     

    源结构应用:

    在介绍分配结构的结算成本要素时,订单结算时要么使用原始科目(默认使用),要么使用结算成本要素(通常很少使用),订单能规集的的东东有哪些呢?很简单就是损益,会计科目只有两大类:资产负债表科目和损益类科目,损益又分成本费用类和收入类

    假设某科研内部订单既规集了费用支出(包括薪酬、差旅和技术使用费等多种费用),同时又发生了一定收入,现在需要将所有的费用支出统一结算到一个”科研支出”科目,而收入则结算到”营业外收入-**”科目,此时就需要使用源结构。

    3.内部订单主数据

    事务代码:Ko01|Ko02|Kob1

    【图】还记得这个是在哪里配置的吧?不记得,等等,今天不那搓衣板是不行了。当然冬天也许暖气片更方便。

    【图】2这个就是控制内部订单是统计型还是实际型的地方,这两个啥区别?难道又不记得。疯掉,金刚经100遍!@!!@¥@#¥#¥%¥&。有没有见过少林寺18铜人?吼吼,别怕别怕。

    【图】这几个地方后台配置都讲过了。就不再讲了吧,还不会?那你就多看看前面的。

    4.内部订单预算费用归集

    事务代码:KO22|KO23|F-02|MB1A

    【图】前面讲过了内部订单只能做年度预算,不能做期间。哎,真是遗憾。

    对内部订单记账时可以通过F-02,记得字段状态组要选内部订单必输。同时,人工费用也是一样的道理,至于发料,是用的移动类型261.料工费都齐了,不知道你是否还有其他疑问?

    5.内部订单结算详解

    事务代码:KO88

     

    这个真的没什么好讲的。自己去体会吧。搞了小半天终于搞完了。唯一的感觉是这段经书念完了更觉得SAP没意思了。哎~~~

    展开全文
  • 根据业务需要定义和建立业务规则,并将其体现数据库中

    第11章 业务规则

    什么是业务规则

    业务规则表示对数据库特定方面实施的某种形式的限制,比如特定字段说明中的元素和给定关系的特征。业务规则基于机构认知和使用其数据的方式建立。机构认知和使用其数据的方式则是从它运作或展开业务的方式中得出。

    说句人话就是使用该数据库的机构自身限定的规则,需要数据库设计人员进行实现。

    业务规则类型

    只有2种,面向数据库面向应用程序

    这两种业务规则都实施某种形式的限制且有效维持整体数据完整性,但是它们的区别在于所建立的地点和方式。

    面向数据库

    面向数据库业务规则规定的限制,可以在数据库的逻辑设计中建立。通过修改各个字段说明元素、关系特征或同时修改这两者,就可以实施给定限制。这些表述限制的语句就是面向数据库业务规则。

    面向应用程序

    面向应用程序业务规则规定的限制,不能在数据库的逻辑设计中建立,而是必须在数据库的物理设计和数据库应用程序的设计中建立。在后两个环境中,这些限制更为有效、更具意义。

    这里只是介绍概念,具体实施就不是数据库设计者该干的事了,所以后面的介绍统一都是介绍面向数据库的业务规则


    业务规则的分类

    字段特有业务规则

    这一类别的业务规则,施加限制的对象是特定字段说明中的元素。

    如以下业务规则:

    订单日期的表示为如下形式“October 28,2016”。

    那么修需要修改字段说明中的显示格式

    关系特有业务规则

    这种业务规则施加的限制会影响到关系的特性。

    如下面这两张表

    STUDENTS

    • Student ID
    • Student Name

    CLASSES

    • Class ID
    • Class Name

    STUDENT CLASS

    • Student ID
    • Class ID

    如果存在下面的限制:

    每门课必须最少有50个学生,最多不超过100个学生。

    那么关联表STUDENT CLASS和CLASSES中,CLASSES相对于STUDENT CLASS的参与度就是(50,100)。


    定义和建立业务规则

    前面介绍了定义,这里开始具体实施。首先是定义和建立字段特有业务规则,接着是关系特有字段业务规则,两者的执行步骤差不多。

    定义和建立字段特有业务规则

    • 选取一个表

    随便选哪张,因为每张表都要考虑。

    • 分别评审每个字段并判断它是否需要限制

    与公司代表进行确认。

    • 为字段定义必要的业务规则

    简单点说就是从代表的话中精简出明确的限制信息。

    • 修改相应字段说明元素,建立规则

    根据3的结论对字段说明做出修改,注意,一个限制可能需要修改不止一个字段说明中的元素。

    • 选定测试该规则的操作

    对该表进行增、删、改操作,看是否会触发该限制。

    如,ORDERS(订单表)中规定代表订单数量的Amount最少为1件,最多为5件,那么在操作时,AMOUNT字段必须限制在一个范围内,操作也是,不能将Amount字段修改为超出该范围的限制。记住这些限制,接下来需要记录下他们。

    • 将该规则记录在业务规则规范表中

    业务规矩规范表具有以下优点:

    • 可以将所有面向数据库的业务规则使用文档说明。
    • 可以将所有面向应用程序的业务规则使用文档记录。
    • 为记录所有业务规则提供一种标准方法。

    业务规则规范表包含下列项:

    • 陈述(statement):描述业务规则本身。
    • 限制(constraint):简单说明该限制如何运用到相应表或字段。

    例:AGENTS(经纪人)表中单一记录与ENTERTAINERS(明星)表中相关联的记录数不得超过25个。即,一个经纪人最多只能带25个明星。

    • 类型(type):指示该规则属于面向数据库面向应用程序类型。
    • 分类(category):指示该规则术语字段特有或关系特有。
    • 测试方法(test on):指示测试该业务规则所施加限制的方法(增、删、改)
    • 受影响结构(structure affected):根据业务规则的类型,该限制将影响某个字段或关系。此处指示该规则影响的字段名称或受影响关系中涉及的表名称。
    • 受影响字段元素(field elements affected):字段特有业务规则会影响到该字段说明的一个或多个元素。此处指示受该规则影响的元素。
    • 受影响关系特征(relationship characteristics affected):关系特有业务规则会影响到该关系的一个或多个特征。此处指示受该规则影响的特征。
    • 采取的措施(action taken):此处指示对字段说明的元素或关系示意图所做出的修改。

    此处书上列出了一个表:

    业务规则规范表

    定义和建立关系特有业务规则

    过程跟上面定义和建立字段特有业务规则差不多。

    • 选取一个关系

    书上没说从哪里去寻找这个关系,我想就从我们前面画的示意图去寻找关系吧,这样应该不会漏掉。

    • 评审该关系判断它是否需要限制
    • 为该关系定义必要的业务规则
    • 修改相应关系特征,建立规则

    具体示例看上面关系特有业务规则

    • 选定测试该规则的操作

    跟前面一样进行增、删、改操作,看是否会触发该限制。

    • 将该规则记录在业务规范表中

    同样记录在业务规则规范表中,表结构跟上面一样。


    验证表

    定义字段特有业务规则时,可能出现这样的情况:一条规则所施加的限制,为给定字段的值的范围定义了一组不同的有效值。通常,这组值包含的条目数量相对固定,值本身也很少变化。

    举个例子就是CITYS(城市表),其中包含字段City Id,City Name字段等,值一般情况下都是不变的,而且是拿来被其他表引用作为外键的,如CUSTOMERS(顾客表)中的Address字段,就是CITYS的外键。

    使用验证表支持业务规则

    当一条业务规则要限制一个字段的值的范围时,可以使用验证表实施这个限制,然后该字段就会从验证表中的相应字段提取它的值。

    具体需要两步:

    1. 定义受该规则影响的字段的父表和验证表之间的关系

    一般情况下就是设置主键和外键

    1. 修改该父表中受影响字段的字段说明的值的范围元素

    一般情况下就是修改:

    删除规则为:限制,

    参与类型为:父表为“强制”,验证表为“可选”

    参与度为:父表为(1,1),父表中的一条记录必须与验证表中的一条记录相关联。验证表为(0,N),这里说N是因为一般情况下是没有限制最大值的,也没有要求验证表中记录必须被父表关联才能存在。

    展开全文
  • 订单系统——提交订单

    万次阅读 2018-06-04 17:19:07
    功能分析1、在订单确认页面点击“提交订单”按钮生成订单。2、请求的url:/order/create3、参数:提交的是表单的数据。保存的数据:订单订单明细、配送地址。a) 向tb_order中插入记录。i. 订单号需要手动生成。...

    1.  提交订单

    1.1. 功能分析

    1、在订单确认页面点击“提交订单”按钮生成订单。

    2、请求的url:/order/create

    3、参数:提交的是表单的数据。保存的数据:订单、订单明细、配送地址。

    a)        向tb_order中插入记录。

    i.         订单号需要手动生成。

    要求订单号不能重复。

    订单号可读性号。

    可以使用redis的incr命令生成订单号。订单号需要一个初始值。

    ii.       Payment:表单数据

    iii.     payment_type:表单数据

    iv.      user_id:用户信息

    v.        buyer_nick:用户名

    vi.      其他字段null

    b)       向tb_order_item订单明细表插入数据。

    i.         Id:使用incr生成

    ii.       order_id:生成的订单号

    iii.     其他的都是表单中的数据。

    c)        tb_order_shipping,订单配送信息

    i.         order_id:生成的订单号

    ii.       其他字段都是表单中的数据。

    d)       使用pojo接收表单的数据。

    可以扩展TbOrder,在子类中添加两个属性一个是商品明细列表,一个是配送信息。

    把pojo放到e3-order-interface工程中。
    /**
     * 用于存放用户提交订单信息
     * @Auther: jun
     * @Date: 2018/6/1 0001 21:45
     * @Description:
     */
    public class OrderInfo extends TbOrder implements Serializable {
    
        private List<TbOrderItem> orderItems;
    
        private TbOrderShipping orderShipping;
    
        public List<TbOrderItem> getOrderItems() {
            return orderItems;
        }
    
        public void setOrderItems(List<TbOrderItem> orderItems) {
            this.orderItems = orderItems;
        }
    
        public TbOrderShipping getOrderShipping() {
            return orderShipping;
        }
    
        public void setOrderShipping(TbOrderShipping orderShipping) {
            this.orderShipping = orderShipping;
        }
    }

    业务逻辑:

    1、接收表单的数据

    2、生成订单id

    3、向订单表插入数据。

    4、向订单明细表插入数据

    5、向订单物流表插入数据。

    6、返回e3Result。

    返回值:e3Result

    1.1. Dao层

    可以使用逆向工程。

    1.1. Service层

    参数:OrderInfo

    返回值:e3Result

    /**
     * 订单Service
     * 订单需要操作三张数据到所有要注入三张表对应生成的mapper
     * @Auther: jun
     * @Date: 2018/6/1 0001 21:51
     * @Description:
     */
    @Service
    public class OrderServiceImpl implements OrderService {
        @Autowired
        private TbOrderMapper tbOrderMapper;
        @Autowired
        private TbOrderItemMapper tbOrderItemMapper;
        @Autowired
        private TbOrderShippingMapper tbOrderShippingMapper;
        @Autowired
        private JedisClient jedisClient;
        @Value("${ORDER_ID_GEN_KEY}")
        private String ORDER_ID_GEN_KEY;
        @Value("${ORDER_ID_START}")
        private String ORDER_ID_START;
        @Value("${ORDER_DETAIL_ID_GEN_KEY}")
        private String ORDER_DETAIL_ID_GEN_KEY;
        @Override
        public E3Result createOrder(OrderInfo orderInfo) {
            //生订单是最好给定初始值所以要判断一下
            if (!jedisClient.exists(ORDER_ID_GEN_KEY)) {
                //设置初始值,从ORDER_ID_START数开始
               jedisClient.set(ORDER_ID_GEN_KEY,ORDER_ID_START);
            }
            //生成订单号,使用redis的incr生成
            String orderId=jedisClient.incr(ORDER_ID_GEN_KEY).toString();
            //补全OrderInfo属性
            //id
            orderInfo.setOrderId(orderId);
            //'状态:1、未付款,2、已付款,3、未发货,4、已发货,5、交易成功,6、交易关闭'
            orderInfo.setStatus(1);
            orderInfo.setCreateTime(new Date());
            orderInfo.setUpdateTime(new Date());
            //插入订单表
            tbOrderMapper.insert(orderInfo);
            //向订单明细表插入数据
            List<TbOrderItem> orderItems=orderInfo.getOrderItems();
            //遍历
            for (TbOrderItem orderItem:orderItems){
                //生成订单明细id
                String orderItem_Id=jedisClient.incr(ORDER_DETAIL_ID_GEN_KEY).toString();
                //补全明细属性
                orderItem.setId(orderItem_Id);
                orderItem.setOrderId(orderId);
                //向明细表插入数据
                tbOrderItemMapper.insert(orderItem);
            }
            //向订单物流表插入数据
            //从订单详细中获得订单物流对象
            TbOrderShipping tbOrderShipping=orderInfo.getOrderShipping();
            //补全属性
            tbOrderShipping.setOrderId(orderId);
            tbOrderShipping.setCreated(new Date());
            tbOrderShipping.setUpdated(new Date());
            //向订单物流插入数据
            tbOrderShippingMapper.insert(tbOrderShipping);
            //返回成功,包含订单号
            return E3Result.ok(orderId);
        }
    }

    1.1. Controller

    请求的url:/order/create

    参数:使用OrderInfo接收

    返回值:逻辑视图。

    业务逻辑:

    1、接收表单提交的数据OrderInfo。

    2、补全用户信息。

    3、调用Service创建订单。

    4、返回逻辑视图展示成功页面

    a)        需要Service返回订单号

    在拦截器中添加用户处理逻辑:

    Controller代码

    /**
     * 提交订单
     *
     * @param orderInfo,model
     * @auther: jun
     * @date: 2018/6/1 0001 22:29
     * @return: java.lang.String
     * @Description:
     */
    @RequestMapping(value = "order/create", method = RequestMethod.POST)
    public String createOrder(OrderInfo orderInfo, Model model, HttpServletRequest request) {
        //取用户信息
        TbUser user = (TbUser) request.getAttribute ( "user" );
        //把用户信息添加到orderInfo中
        orderInfo.setUserId ( user.getId () );
        orderInfo.setBuyerNick ( user.getUsername () );
        //调用服务生产订单
        E3Result result=orderService.createOrder (orderInfo);
        //如果订单生成成功,需要删除购物车
        if (result.getStatus ()==200){
            cartService.clearCartItem (user.getId ());
        }
        //返回页面需要参数
        //把订单号转递给页面
        request.setAttribute ("orderId",result.getData ());
        request.setAttribute ("payment",orderInfo.getPayment ());
        //返回逻辑视图
        return "success";
    }

    展开全文
  • 订单系统

    千次阅读 2018-10-28 18:21:44
    1、购物车页面点击“去结算”按钮跳转到订单确认页面。  a) 展示商品列表  b) 配送地址列表  c) 选择支付方式 2、展示订单确认页面之前,应该确认用户身份。  a) 使用拦截器实现。  b) Cookie中取...

    3 订单系统

    3.1 功能分析

    1、在购物车页面点击“去结算”按钮跳转到订单确认页面。

                 a)  展示商品列表

                 b)  配送地址列表

                 c)  选择支付方式

    2、展示订单确认页面之前,应该确认用户身份。

                 a)  使用拦截器实现。

                 b)  Cookie中取token

                 c)  取不到token跳转到登录页面

                 d)  取到token,根据token查询用户信息。

                 e)  如果没有用户信息,登录过期跳转到登录页面

                 f)  取到用户信息,放行。

    3、提交订单

                 a)  生成订单

                 b)  展示订单提交成功页面。

     

    订单系统系统:订单确认页面、订单提交成功页面。

    订单服务系统

    3.2 工程搭建

    创建一个订单服务系统:

    e3-order(可以参考e3-manager整合。)

       |--e3-order-interface

       |--e3-order-Service

    表现层工程:

    e3-order-web打包方式war。

    复制依赖到e3-order工程:

    <dependencies>
            <dependency>
                <groupId>cn.e3mall</groupId>
                <artifactId>e3-common</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>
        <!-- 配置tomcat插件 -->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <configuration>
                        <path>/</path>
                        <port>8091</port>
                    </configuration>
                </plugin>
            </plugins>
        </build>

    复制依赖到e3-order-interface工程:

    <dependencies>
            <dependency>
                <groupId>cn.e3mall</groupId>
                <artifactId>e3-manager-pojo</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>

    复制依赖到e3-order-service工程:

    <dependencies>
            <dependency>
                <groupId>cn.e3mall</groupId>
                <artifactId>e3-manager-dao</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>cn.e3mall</groupId>
                <artifactId>e3-order-interface</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <!-- spring的依赖 -->
            <!-- Spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
            <!-- dubbo相关 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <exclusions>
                    <!-- 排除dubbo自带的spring 防止冲突 -->
                    <exclusion>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring</artifactId>
                    </exclusion>
                    <!-- 排除dubbo自带的netty 防止冲突 -->
                    <exclusion>
                        <groupId>org.jboss.netty</groupId>
                        <artifactId>netty</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
            </dependency>
            <dependency>
                <groupId>com.github.sgroschupf</groupId>
                <artifactId>zkclient</artifactId>
            </dependency>
        </dependencies>

    1.复制所有配置文件到e3-order-service工程

    2.清空resource.properties配置文件

    3.订单系统用不上redis,删除redis配置文件

    4.修改applicationContext-service.xml配置文件:

    5.创建包:

    6.修改applicationContext-trans.xml配置文件:

    7.复制web.xml修改:

    复制依赖到e3-order-web工程:

    <dependencies>
            <dependency>
                <groupId>cn.e3mall</groupId>
                <artifactId>e3-order-interface</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <!-- JSP相关 -->
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jsp-api</artifactId>
                <scope>provided</scope>
            </dependency>
            <!-- spring的依赖 -->
            <!-- Spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
            <!-- dubbo相关 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.jboss.netty</groupId>
                        <artifactId>netty</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
            </dependency>
            <dependency>
                <groupId>com.github.sgroschupf</groupId>
                <artifactId>zkclient</artifactId>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <!-- 配置Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <configuration>
                        <path>/</path>
                        <port>8092</port>
                    </configuration>
                </plugin>
            </plugins>
        </build>

    1.复制所有配置文件:

    2.清空resource.properties配置文件内容

    3.修改springmvc.xml配置文件:

    4.创建包:

    5.复制web.xml,将工程名全部改为e3-order-web

    6.复制订单静态资源

     

    3.3 展示订单确认页面

    3.3.1 功能分析

    e3-order-web工程加入依赖(需要调购物车的接口):

    e3-order-web工程引用服务:

     

            1. 在e3-cart-web工程购物车页面点击“去结算”按钮跳转到订单确认页面。

            2. 请求的url:

    /order/order-cart

            3. 参数:没有参数。

            4. 购物车商品数据从cookie中取出来的。可以在订单系统中取到cookie中的购物车数据。

            5. 配送地址列表,需要用户登录。需要根据用户id查询收货地址列表。静态数据。

            6. 支付方式。静态数据。

            7. 返回值:逻辑视图String,展示订单确认页面。

    3.3.2 Dao层、Service层(没有)

    需要根据用户id查询收货地址列表。没有此功能。

    3.3.3 表现层

    请求的url:/order/order-cart

    参数:无

    业务逻辑:

    从cookie中取商品列表展示到页面。

    返回值:逻辑视图。


    在展示订单确认页面之前,需要对用户身份进行认证,要求用户必须登录。

    3.4 用户身份认证

    3.4.1 功能分析

          1. 使用springmvc的拦截器实现。需要实现一个接口HandlerInterceptor接口。

          2. 业务逻辑

               a)  从cookie中取token。

               b)  没有token,需要跳转到登录页面。

               c)  有token。调用sso系统的服务,根据token查询用户信息。

               d)  如果查不到用户信息。用户登录已经过期。需要跳转到登录页面。

               e)  查询到用户信息。放行。

          3. 在springmvc.xml中配置拦截器。

    3.4.2 拦截器实现

    e3-order-web工程pom添加依赖:

    e3-order-web引用sso工程服务:

     

    3.4.3 配置拦截器

    中springmvc.xml中配置拦截器。

    3.4.4 实现sso系统的回调

    通过登录方法传递给页面,如果有值登录完成时回到订单页面

    1.课程计划

    1. 订单提交功能完成
    2. 使用mycat实现数据分片
    3. 使用mycat实现数据库读写分离

    2.提交订单

    2.1 功能分析

    1. 在订单确认页面点击“提交订单”按钮生成订单。
    2. 请求的url:/order/create
    3. 参数:提交的是表单的数据。保存的数据:订单、订单明细、配送地址。

                 a )  向tb_order中插入记录。

                        i.  订单号需要手动生成。

                            要求订单号不能重复。

                           订单号可读性号。

                           可以使用redis的incr命令生成订单号。订单号需要一个初始值。

                       ii.  Payment:表单数据

                       iii. payment_type:表单数据

                       iv. user_id:用户信息

                       v.  buyer_nick:用户名

                       vi. 其他字段null

                 b )  向tb_order_item订单明细表插入数据。

                        i.   Id:使用incr生成

                        ii.  order_id:生成的订单号

                        iii. 其他的都是表单中的数据。

                 c )   tb_order_shipping,订单配送信息

                        i.  order_id:生成的订单号

                        ii.  其他字段都是表单中的数据。

                 d )  使用pojo接收表单的数据。

                        可以扩展TbOrder,在子类中添加两个属性一个是商品明细列表,一个是配送信息。

                        把pojo放到e3-order-interface工程中。

    加入reids配置文件直接使用:

    public class OrderInfo extends TbOrder implements Serializable{

          private List<TbOrderItem> orderItems;

          private TbOrderShipping orderShipping;

          public List<TbOrderItem> getOrderItems() {

                return orderItems;

          }

          public void setOrderItems(List<TbOrderItem> orderItems) {

                this.orderItems = orderItems;

          }

          public TbOrderShipping getOrderShipping() {

                return orderShipping;

          }

          public void setOrderShipping(TbOrderShipping orderShipping) {

                this.orderShipping = orderShipping;

          }

         

    }

    业务逻辑:

    1. 接收表单的数据
    2. 生成订单id
    3. 向订单表插入数据。
    4. 向订单明细表插入数据
    5. 向订单物流表插入数据。
    6. 返回e3Result。

     

    返回值:e3Result

    2.2 Dao层

    可以使用逆向工程。

    2.3 Service层

    参数:OrderInfo

    返回值:e3Result

    ORDER_ID_GEN_KEY:redis自增订单id

    ORDER_ID_START:redis订单起始id数

    ORDER_DETAIL_ID_GEN_KEY:redis自增订单明细id

    @Service

    public class OrderServiceImpl implements OrderService {

     

          @Autowired

          private TbOrderMapper orderMapper;

          @Autowired

          private TbOrderItemMapper orderItemMapper;

          @Autowired

          private TbOrderShippingMapper orderShippingMapper;

          @Autowired

          private JedisClient jedisClient;

         

          @Value("${ORDER_GEN_KEY}")

          private String ORDER_GEN_KEY;

          @Value("${ORDER_ID_BEGIN}")

          private String ORDER_ID_BEGIN;

          @Value("${ORDER_ITEM_ID_GEN_KEY}")

          private String ORDER_ITEM_ID_GEN_KEY;

         

          @Override

          public e3Result createOrder(OrderInfo orderInfo) {

                // 1、接收表单的数据

                // 2、生成订单id

                if (!jedisClient.exists(ORDER_GEN_KEY)) {

                      //设置初始值

                      jedisClient.set(ORDER_GEN_KEY, ORDER_ID_BEGIN);

                }

                String orderId = jedisClient.incr(ORDER_GEN_KEY).toString();

                orderInfo.setOrderId(orderId);

                orderInfo.setPostFee("0");

                //1、未付款,2、已付款,3、未发货,4、已发货,5、交易成功,6、交易关闭

                orderInfo.setStatus(1);

                Date date = new Date();

                orderInfo.setCreateTime(date);

                orderInfo.setUpdateTime(date);

                // 3、向订单表插入数据。

                orderMapper.insert(orderInfo);

                // 4、向订单明细表插入数据

                List<TbOrderItem> orderItems = orderInfo.getOrderItems();

                for (TbOrderItem tbOrderItem : orderItems) {

                      //生成明细id

                      Long orderItemId = jedisClient.incr(ORDER_ITEM_ID_GEN_KEY);

                      tbOrderItem.setId(orderItemId.toString());

                      tbOrderItem.setOrderId(orderId);

                      //插入数据

                      orderItemMapper.insert(tbOrderItem);

                }

                // 5、向订单物流表插入数据。

                TbOrderShipping orderShipping = orderInfo.getOrderShipping();

                orderShipping.setOrderId(orderId);

                orderShipping.setCreated(date);

                orderShipping.setUpdated(date);

                orderShippingMapper.insert(orderShipping);

                // 6、返回e3Result

                return e3Result.ok(orderId);

          }

     

    }

    2.4 Controller

    请求的url:/order/create

    参数:使用OrderInfo接收

    返回值:逻辑视图。

    业务逻辑:

    1. 接收表单提交的数据OrderInfo。
    2. 补全用户信息。
    3. 调用Service创建订单。
    4. 返回逻辑视图展示成功页面

                a ) 需要Service返回订单号

                b ) 当前日期加三天。

    在拦截器中添加用户处理逻辑:

    添加清空用户购物车方法:

    安装e3-cart-interface工程

    安装e3-order-interface工程

    发布服务:

    引用服务:

    启动工程


    3.1 什么是MyCAT?3. MyCAT介绍

      简单的说,MyCAT就是:

      一个彻底开源的,面向企业应用开发的“大数据库集群”

      支持事务、ACID、可以替代Mysql的加强版数据库

      一个可以视为“Mysql”集群的企业级数据库,用来替代昂贵的Oracle集群

      一个融合内存缓存技术、Nosql技术、HDFS大数据的新型SQL Server

      结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品

      一个新颖的数据库中间件产品

     

      MyCAT的目标是:低成本的将现有的单机数据库和应用平滑迁移到“云”端,解决数据存储和业务规模迅速增长情况下的数据瓶颈问题。

    3.2 MyCAT的关键特性

        支持 SQL 92标准

        支持Mysql集群,可以作为Proxy使用

        支持JDBC连接ORACLE、DB2、SQL Server,将其模拟为MySQL  Server使用

        支持galera for mysql集群,percona-cluster或者mariadb cluster,提供高可用性数据分片集群

        自动故障切换,高可用性

        支持读写分离,支持Mysql双主多从,以及一主多从的模式

        支持全局表,数据自动分片到多个节点,用于高效表关联查询

        支持独有的基于E-R 关系的分片策略,实现了高效的表关联查询

        多平台支持,部署和实施简单

    3.3 MyCAT架构

    如图所示:MyCAT使用Mysql的通讯协议模拟成了一个Mysql服务器,并建立了完整的Schema(数据库)、Table (数据表)、User(用户)的逻辑模型,并将这套逻辑模型映射到后端的存储节点DataNode(MySQL Instance)上的真实物理库中,这样一来,所有能使用Mysql的客户端以及编程语言都能将MyCAT当成是Mysql Server来使用,不必开发新的客户端协议。

    4. Mycat解决的问题

    1. 性能问题
    2. 数据库连接过多
    3. E-R分片难处理
    4. 可用性问题
    5. 成本和伸缩性问题

    4.1 Mycat对多数据库的支持

    5. 分片策略

    MyCAT支持水平分片与垂直分片:

      水平分片:一个表格的数据分割到多个节点上,按照行分隔。

      垂直分片:一个数据库中多个表格A,B,C,A存储到节点1上,B存储到节点2上,C存储到节点3上。

    MyCAT通过定义表的分片规则来实现分片,每个表格可以捆绑一个分片规则,每个分片规则指定一个分片字段并绑定一个函数,来实现动态分片算法。

     

    1. Schema:逻辑库,与MySQL中的Database(数据库)对应,一个逻辑库中定义了所包括的Table。
    2. Table:表,即物理数据库中存储的某一张表,与传统数据库不同,这里的表格需要声明其所存储的逻辑数据节点DataNode。在此可以指定表的分片规则。
    3. DataNode:MyCAT的逻辑数据节点,是存放table的具体物理节点,也称之为分片节点,通过DataSource来关联到后端某个具体数据库上
    4. DataSource:定义某个物理库的访问地址,用于捆绑到Datanode上

    6. Mycat的下载及安装

    6.1 下载mycat

    官方网站:

    http://www.mycat.org.cn/

     

    github地址

    https://github.com/MyCATApache

    6.2 Mycat安装

    第一步:把MyCat的压缩包上传到linux服务器

    第二步:解压缩,得到mycat目录

    [root@huangh mycat]# tar zxf Mycat-server-1.4-release-20151019230038-linux.tar.gz

    第三步:进入mycat/bin,启动MyCat

    [root@huangh mycat]#  cp -r mycat /usr/local/

    [root@huangh mycat]# cd /usr/local/mycat/

    [root@huangh mycat]# cd bin/

    [root@huangh bin]# ./mycat console

     

    启动命令:./mycat start

    停止命令:./mycat stop

    重启命令:./mycat restart

     

    注意:可以使用mysql的客户端直接连接mycat服务。默认服务端口为8066

    7. Mycat分片

    7.1 需求

    把商品表分片存储到三个数据节点上。

    7.2 安装环境

    mysql节点1环境

    操作系统版本 : centos6.4

    数据库版本 : mysql-5.6

    mycat版本 :1.4 release

    数据库名 : db1、db3

    ip:192.168.25.134

     

    mysql节点2环境

    操作系统版本 : centos6.4

    数据库版本 : mysql-5.6

    mycat版本 :1.4 release

    数据库名 : db2

    ip:192.168.25.166

     

    MyCat安装到节点1上(需要安装jdk)

    7.3 配置schema.xml(192.168.25.171)

    7.3.1 Schema.xml介绍

    Schema.xml作为MyCat中重要的配置文件之一,管理着MyCat的逻辑库、表、分片规则、DataNode以及DataSource。弄懂这些配置,是正确使用MyCat的前提。这里就一层层对该文件进行解析。

     

    schema 标签用于定义MyCat实例中的逻辑库

    Table 标签定义了MyCat中的逻辑表

    dataNode 标签定义了MyCat中的数据节点,也就是我们通常说所的数据分片。

    dataHost标签在mycat逻辑库中也是作为最底层的标签存在,直接定义了具体的数据库实例、读写分离配置和心跳语句。

    注意:若是LINUX版本的MYSQL,则需要设置为Mysql大小写不敏感,否则可能会发生表找不到的问题。

    在MySQL的配置文件中my.ini [mysqld] 中增加一行

      lower_case_table_names = 1

    [root@huangh bin]# vim /etc/my.cnf

    [root@huangh bin]# cd ..

    [root@huangh mycat]# cd conf/

     

    7.3.2 Schema.xml配置

    [root@huangh conf]# vim schema.xml

     

    1. <schema name="e3mall-32" checkSQLschema="false" sqlMaxLimit="100">

    数据库名为e3mall-32

    2.<table name="TB_ITEM" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />

    表名为TB_ITEM的表放到dn1,dn2,dn3的节点上,规则为系统分配的auto-sharding-long(根据id范围分配) 可以自定义

    3.<dataNode name="dn1" dataHost="localhost1" database="db1" />

    dn1节点 数据主机名为localhost1 数据库为db1

    4.

    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"

                  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">

                  <heartbeat>select user()</heartbeat>

                  <!-- can have multi write hosts -->

                  <writeHost host="hostM1" url="192.168.25.134:3306" user="root"

                         password="root">

                         <!-- can have multi read hosts -->

     

                  </writeHost>

           </dataHost>

    配置数据主机名为localhost1的url数据库ip地址和端口号 user数据名账号 password数据库密码

    通过select user()检测数据库心跳是否正常

     


    7.4.1 Server.xml介绍7.4 配置server.xml

    server.xml几乎保存了所有mycat需要的系统配置信息。最常用的是在此配置用户名、密码及权限。

    7.4.2 Server.xml配置

    [root@huangh conf]# vim server.xml 

     

    7.5 配置rule.xml

    rule.xml里面就定义了我们对表进行拆分所涉及到的规则定义。我们可以灵活的对表使用不同的分片算法,或者对表使用相同的算法但具体的参数不同。这个文件里面主要有tableRule和function这两个标签。在具体使用过程中可以按照需求添加tableRule

    和function。

    此配置文件可以不用修改,使用默认即可。

    7.6 测试分片

    7.6.1 创建表

    配置完毕后,重新启动mycat。使用mysql客户端连接mycat,创建表。

    [root@huangh conf]# cd ..

    [root@huangh mycat]# bin/mycat start

    [root@huangh mycat]# bin/mycat status

    复制下面sql到mycat服务器连接中执行 可以看到配置的节点服务器下的数据库都有表生成

    -- ----------------------------

    -- Table structure for tb_item

    -- ----------------------------

    DROP TABLE IF EXISTS `tb_item`;

    CREATE TABLE `tb_item` (

      `id` bigint(20) NOT NULL COMMENT '商品id,同时也是商品编号',

      `title` varchar(100) NOT NULL COMMENT '商品标题',

      `sell_point` varchar(500) DEFAULT NULL COMMENT '商品卖点',

      `price` bigint(20) NOT NULL COMMENT '商品价格,单位为:分',

      `num` int(10) NOT NULL COMMENT '库存数量',

      `barcode` varchar(30) DEFAULT NULL COMMENT '商品条形码',

      `image` varchar(500) DEFAULT NULL COMMENT '商品图片',

      `cid` bigint(10) NOT NULL COMMENT '所属类目,叶子类目',

      `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '商品状态,1-正常,2-下架,3-删除',

      `created` datetime NOT NULL COMMENT '创建时间',

      `updated` datetime NOT NULL COMMENT '更新时间',

      PRIMARY KEY (`id`),

      KEY `cid` (`cid`),

      KEY `status` (`status`),

      KEY `updated` (`updated`)

    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='商品表';

     

    -- ----------------------------

    -- Table structure for tb_user

    -- ----------------------------

    DROP TABLE IF EXISTS `tb_user`;

    CREATE TABLE `tb_user` (

      `id` bigint(20) NOT NULL AUTO_INCREMENT,

      `username` varchar(50) NOT NULL COMMENT '用户名',

      `password` varchar(32) NOT NULL COMMENT '密码,加密存储',

      `phone` varchar(20) DEFAULT NULL COMMENT '注册手机号',

      `email` varchar(50) DEFAULT NULL COMMENT '注册邮箱',

      `created` datetime NOT NULL,

      `updated` datetime NOT NULL,

      PRIMARY KEY (`id`),

      UNIQUE KEY `username` (`username`) USING BTREE,

      UNIQUE KEY `phone` (`phone`) USING BTREE,

      UNIQUE KEY `email` (`email`) USING BTREE

    ) ENGINE=InnoDB AUTO_INCREMENT=37 DEFAULT CHARSET=utf8 COMMENT='用户表';

    重启生效配置bin/mycat restart

    7.6.2 插入数据

    插入数据时必须带上所有列名 不能省略

    复制sql到mycat服务器连接中执行

    7.6.3 分片测试

    由于配置的分片规则为“auto-sharding-long”,所以mycat会根据此规则自动分片。

    每个datanode中保存一定数量的数据。根据id进行分片

    经测试id范围为:

    Datanode1:1~5000000条数据

    Datanode2:5000000~10000000条数据

    Datanode3:10000001~15000000条数据

     

    当15000000以上的id插入时报错:

    [Err] 1064 - can't find any valid datanode :TB_ITEM -> ID -> 15000001

    此时需要添加节点了。

     

    8. Mycat读写分离

    数据库读写分离对于大型系统或者访问量很高的互联网应用来说,是必不可少的一个重要功能。对于MySQL来说,标准的读写分离是主从模式,一个写节点Master后面跟着多个读节点,读节点的数量取决于系统的压力,通常是1-3个读节点的配置

    Mycat读写分离和自动切换机制,需要mysql的主从复制机制配合。

    8.1 Mysql的主从复制

    主从配置需要注意的地方

    1、主DB server和从DB server数据库的版本一致

    2、主DB server和从DB server数据库数据一致[ 这里就会可以把主的备份在从上还原,也可以直接将主的数据目录拷贝到从的相应数据目录]

    3、主DB server开启二进制日志,主DB server和从DB server的server_id都必须唯一

     

    8.2 Mysql主服务器配置(192.168.25.171)

    第一步:修改my.cnf文件:

    [root@huangh ~]# vim /etc/my.cnf

    在[mysqld]段下添加:


    第二步:重启mysql服务

    [root@huangh ~]# service mysqld restart

    [root@huangh ~]# mysql -uroot -p123456

    第三步:建立账户并授权slave

    mysql>GRANT FILE ON *.* TO 'backup'@'%' IDENTIFIED BY '123456';

    mysql>GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* to 'backup'@'%' identified by '123456';

    #一般不用root帐号,“%”表示所有客户端都可能连,只要帐号,密码正确,此处可用具体客户端IP代替,如192.168.145.226,加强安全。

    刷新权限

    mysql> FLUSH PRIVILEGES;

     

    查看mysql现在有哪些用户

    mysql>select user,host from mysql.user;

     

    第四步:查询master的状态

    mysql> show master status;

    8.3 Mysql从服务器配置(192.168.25.172)

    第一步:修改my.cnf文件

    [mysqld]

    server-id=172

     

    第二步:配置从服务器

    mysql> change master to master_host='192.168.25.171',master_port=3306,master_user='backup',master_password='123456',master_log_file='mysql-bin.000001',master_log_pos=55842;

    报错:

    mysql> use mysql

    mysql> drop table slave_master_info;
    Query OK, 0 rows affected (0.01 sec)

    mysql> drop table slave_relay_log_info;
    Query OK, 0 rows affected (0.02 sec)

    mysql> drop table slave_worker_info;
    Query OK, 0 rows affected (0.00 sec)

    mysql> drop table innodb_index_stats;
    Query OK, 0 rows affected (0.01 sec)

    mysql> drop table innodb_table_stats;
    Query OK, 0 rows affected (0.01 sec)

     

    重新建表,service mysqld restart重启

    重新从主服务器查找master_log_pos,修改

    mysql> change master to master_host='192.168.25.171',master_port=3306,master_user='backup',master_password='123456',master_log_file='mysql-bin.000001',master_log_pos=55842;

     

     

    注意语句中间不要断开,master_port为mysql服务器端口号(无引号),master_user为执行同步操作的数据库账户,“120”无单引号(此处的120就是show master status 中看到的position的值,这里的mysql-bin.000001就是file对应的值)。

     

    第二步:启动从服务器复制功能

    Mysql>start slave;

     

    第三步:检查从服务器复制功能状态:

    mysql> show slave status

     

    ……………………(省略部分)

    Slave_IO_Running: Yes //此状态必须YES

    Slave_SQL_Running: Yes //此状态必须YES

    ……………………(省略部分)

    注:Slave_IO及Slave_SQL进程必须正常运行,即YES状态,否则都是错误的状态(如:其中一个NO均属错误)。

    错误处理:

    如果出现此错误:

    Fatal error: The slave I/O thread stops because master and slave have equal MySQL server UUIDs; these UUIDs must be different for replication to work.

    因为是mysql是克隆的系统所以mysql的uuid是一样的,所以需要修改。

    解决方法:

    删除/var/lib/mysql/auto.cnf文件,重新启动服务。

    [root@huanghh mycat]# service mysqld restart

    1.192.168.25.172从服务器开启  mysql> start slave;

    2.向主服务器192.168.25.171插入数据

    3.查看从服务器数据

    以上操作过程,从服务器配置完成。

    8.4 Mycat配置(192.168.25.171)

    [root@huangh conf]# cd /usr/local/mycat/conf

    Mycat 1.4 支持MySQL主从复制状态绑定的读写分离机制,让读更加安全可靠,配置如下:

    <dataNode name="dn1" dataHost="localhost1" database="db1" />

        <dataNode name="dn2" dataHost="localhost2" database="db2" />

        <dataNode name="dn3" dataHost="localhost1" database="db3" />

        <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"

            writeType="0" dbType="mysql" dbDriver="native" switchType="2"  slaveThreshold="100">

            <heartbeat>show slave status</heartbeat>

            <writeHost host="hostM" url="192.168.25.171:3306" user="root"

                password="123456">

                <readHost host="hostS" url="192.168.25.172:3306" user="root"

                password="123456" />

            </writeHost>

        </dataHost>

     

     (1) 设置 balance="1"与writeType="0"

     Balance参数设置:

           1. balance=“0”, 所有读操作都发送到当前可用的writeHost上。

           2. balance=“1”,所有读操作都随机的发送到readHost。

           3. balance=“2”,所有读操作都随机的在writeHost、readhost上分发

    WriteType参数设置:

           1. writeType=“0”, 所有写操作都发送到可用的writeHost上。

           2. writeType=“1”,所有写操作都随机的发送到readHost。

           3. writeType=“2”,所有写操作都随机的在writeHost、readhost分上发。

     “readHost是从属于writeHost的,即意味着它从那个writeHost获取同步数据,因此,当它所属的writeHost宕机了,则它也不会再参与到读写分离中来,即“不工作了”,这是因为此时,它的数据已经“不可靠”了。基于这个考虑,目前mycat 1.3和1.4版本中,若想支持MySQL一主一从的标准配置,并且在主节点宕机的情况下,从节点还能读取数据,则需要在Mycat里配置为两个writeHost并设置banlance=1。”

     (2) 设置 switchType="2" 与slaveThreshold="100"

      switchType 目前有三种选择:

      -1:表示不自动切换

      1 :默认值,自动切换

      2 :基于MySQL主从同步的状态决定是否切换

      “Mycat心跳检查语句配置为 show slave status ,dataHost 上定义两个新属性: switchType="2" 与slaveThreshold="100",此时意味着开启MySQL主从复制状态绑定的读写分离与切换机制。Mycat心跳机制通过检测 show slave status 中的 "Seconds_Behind_Master", "Slave_IO_Running", "Slave_SQL_Running" 三个字段来确定当前主从同步的状态以及Seconds_Behind_Master主从复制时延。“

    使用时启动mycat,直接连接mycat。mycat自动实现读写分离。

    展开全文
  • 怪不得技术总监发狠话:谁要是敢处理诸如 商品金额、订单交易、以及货币计算时用浮点型数据(double/float),直接让我们走人! 原因出哪里? 我们就以第一个典型现象为例来分析一下: System.out.println( 1f ...
  • redis事件监听及在订单系统中的使用

    万次阅读 2017-08-30 15:37:23
    通常网上买好物品,或者说手机扫码后,点击付款,这时就会向后台发送请求,生成订单信息,以及够买商品的信息存入到数据库对应的表比如:订单表和商品销售表,或者还有物流信息表等。简单起见,就拿扫码购物来说,...
  • 为未来企业而定义

    千次阅读 2014-03-04 13:14:58
    为未来企业而定义一、未来企业到底应该是什么样?我把企业简单粗暴分为:农业、制造业、零售与服务业。而世界也是经历了:农业从牛犁耕种到现代大农业、制造业从手工作坊到现代大工业制造、零售业从小卖店到商超MALL...
  • SAP SD基础知识之订单中装运相关的功能 I ...系统会自动带出一个shipping point,你可以有限的范围内修改。 Shipping point依赖于三个元素的组合:delivery plant/shipping condi...
  • CO -内部订单

    千次阅读 2012-12-21 13:51:30
    这种功能分类反映不同的订单类型中,其属性定义系统中处理订单的方式。SAP系统内内部定单分为两类:实际定单和统计性定单。统计性定单,例如用项目内部订单来管理在建工程,月末无须结转成本。 1.2内部订单的...
  • 订单相关问题

    千次阅读 2020-05-29 10:10:43
    创建订单时,要同时往订单表和订单商品表中插入数据,那这些插入数据的INSERT必须一个数据库事务中执行,数据库的事务可以确保:执行这些INSERT语句,共赴生死! 但还有很多难以发现的坑存在 1 基本功能和数据表 ...
  • 订单拆单 入门

    千次阅读 2019-01-31 10:48:10
    用户平台上下了一单。但因商品由不同商家或不同仓库分别寄给用户,产生了多张物流单和不同的到货时间。而到货时间,又与申请换货有关。整个业务逻辑耦合程度很高。为了解耦,各大电商平台便纷纷拆单。保证每张订单...
  • 订单拆单问题的解决

    万次阅读 2018-06-01 16:46:47
    拆单产生的原因:用户平台上下了一单。但因商品由不同商家或不同仓库分别寄给用户,产生了多张物流单和不同的到货时间。而到货时间,又与申请换货有关。整个业务逻辑耦合程度很高。为了解耦,各大电商平台便纷纷...
  • 常见业务场景:订单在30分钟内还未支付则自动取消。 该业务的其他实现方案: 使用Redis,设置过期时间,监听过期事件。 使用RabbitMQ的过期队列与死信队列,设置消息的存活时间,设置的时间内未被消费,...
  • 设计交易系统时,稳定性、可扩展性、可维护性都是我们需要关注的重点。本文将对如何通过状态机交易系统中的应用解决上述问题做出一些探讨。 关于马蜂窝机票订单交易系统 交易系统往往存在订单维度多、状态多、...
  • SAP 生产订单工序

    千次阅读 2013-08-01 13:41:15
    SAP 生产订单工序外协对应的工序报工后,对应的采购订单自动入库 对于工序外协的采购订单,一般不会涉及到库存管理,收货也...1.定义控制码:用于质检和外协 2.该物料维护03的检验类型,下达生产订单自动产生检
  • 采购订单中,收货和发票收据可以由后台配置的订单类型做不同定义代入一个默认值,也可以下达订单时手动指定或更改默认定义;其含义帮助信息中显示如下: 如果仅从采购层面来说,收货代表该采购订单中的项目...
  • IOT语义互操作性之词汇定义

    千次阅读 2018-02-18 00:00:00
    就早当年自己离开高通公司的时候,曾经自以为是地将未来的互联网分为3个方向:1)可信的互联网2)安全的互联网3)无所不在的互联网只是限于能力有限,却始终没有什么建树。如今,区块链的出现可能会解决可信的...
  • SAP生产订单预留

    千次阅读 2019-04-17 10:04:26
    1.预留创建的时机:预留凭证是生产订单保存的时候创建的,预留编号和生产订单一一对应。但是读取BOM的时候就已经创建了临时文件,并占用了编号!(这个号码是提前分配,所以预留可能会不连号!!!和预留的编号...
  • SAP中订单结算KO88\ CO88\KO8G的区别

    千次阅读 2020-06-16 15:21:18
    KO88 是针对单一订单进行结算,结算时可以手动指定订单号; CO88 是针对单一工厂下的订单进行结算的; KO8G 是自定义结算范围的订单进行结算的,通过定义变式设置结算范围:如公司代码、工厂、订单订单...
  • PostgreSQL 9.4文档 第5章 数据定义

    千次阅读 2015-01-28 22:53:14
    关系数据库中,原始数据存储表中,因此本章主要涉及如何创建和修改表,以及控制表中存储的数据的特性。然后,我们讨论了如何模式中组织表,以及表的权限管理。最后,我们将简单了解与数据存储有关的其他特性,...
  • 销售订单配置项目说明

    千次阅读 2015-10-26 14:55:35
    Sales Document Categ: SD内不同文件类型的分类,例如报价单,销售订单,运货单和发票等。 Sales Document Block:控制这个文件类型是否已经被冻结。有三个选择,如果该字段为空则表明这个文件类型没有被冻结,如果...
  • 6:自定义流程:根据公司规模和人员配备,可以自定义订单处理和售后服务流程,对于规模较小的卖家,可以定义两步完成订单处理,例如审核确认和打包发货,对于大卖家可以定义三步或四步;每一步的操作可以自行设置; ...
  • ERP系统-采购子系统-采购订单

    千次阅读 2020-07-02 22:38:27
    采购订单是企业根据产品的用料计划和实际能力以及相关的因素,所制定的切实可行的采购订单计划,并下达至供应商执行,执行的过程中要注意对订单进行跟踪,以使企业能从采购环境中购买到企业所需的商品,为生产部门...
  • ERP系统-销售子系统-销售订单

    千次阅读 2020-07-02 22:40:06
    文章已个人经验总结整理,如果有不足与欠缺的功能点或者是有表达错误的点的话请评论区指正,我会及时进行修改处理更新!!!!! 1.定义: 销售订单,指的是企业与客户之间签订的一种销售协议,销售订单实现企业...
  • 电商订单仓储ERP管理系统是一款网店综合业务管理系统,它以网店订单为核心,集成商品、采购、仓储、营销(站内信、邮件、售后)、物流、决策分析、财务等功能为一体的网店 ERP 软件系统。它充分利用电商务平台提供的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,047
精华内容 11,618
关键字:

在手订单的定义