精华内容
下载资源
问答
  • 京东平台和商家的不同合作模式
    千次阅读
    2018-08-22 16:55:29

    京东平台和商家的不同合作模式

    1. FBP 京东给商家一个独立操作的后台(自行上传产品,描述,价格), 商家五地入库(北京,上海,广州,成都,武汉),从仓储到配送到客服都是京东来操作,京东本身自营的产品所有能享受的服务,商家都能享受(支持211限时达,自提,货到付款,POS刷卡),客户体验值最高。商家必须具备一般纳税人资格,需要给京东开具增值税发票(注:不是普通发票)
      FBP有60天滞销,超过60天没销售的商品,需要自己处理。

    2. LBP 京东给商家一个独立操作的后台(自行上传产品,描述,价格), 商家无须入库,要求订单产生后12小时内将产生的订单包装好发货,分别发货到京东的五地仓储,36小时内到京东商城仓库,由京东来开具给消费者的发票。商家必须具备一般纳税人资格,需要给京东开具增值税发票(注:不是普通发票)

    3. SOP 京东给商家一个独立操作的后台(自行上传产品,描述,价格),跟淘宝商城模式比较类似, 要求订单产生后12小时内发货,由商家来承担所有的服务。商家不需要给京东开具增值税发票,需要商家每单给顾客开普票。
      目前只支持在线支付,即消费者通过支付宝、网银等在线支付后,商家才能发货;

    4. SOPL 京东给商家一个独立操作的后台(自行上传产品,描述,价格), 商家无须入库,要求订单产生后12小时内将产生的订单包装好发货,分别发货到京东的五地仓储,36小时内到京东商城仓库,不需要给京东开具增值税发票,由商家来开具给消费者的发票。

    更多相关内容
  • 商业合作模式有几种

    万次阅读 2019-06-18 23:36:00
    一般公司之间合作有以下: 一、六种合作模式 1、资源互换:资源互换是一种双方商定在一段时间内彼此相互交换现金的金融交易。 2、利益均分:利益均分是在一定的利益格局和体系下出现的利益体系相对和平共处、相.....

    公司合作首先要看公司的发展、定位已经公司双方的实力,前期沟通,了解很重要,切不可盲目。一般公司之间合作有以下:

    一、六种合作模式

    1、资源互换:资源互换是一种双方商定在一段时间内彼此相互交换现金的金融交易

    2、利益均分:利益均分是在一定的利益格局和体系下出现的利益体系相对和平共处、相对均势的状态

    3、股权转让:股权转让,是公司股东依法将自己的股东权益有偿转让给他人,使他人取得股权的民事法律行为。

    4、买断合作:买断,是一种市场经营行为。一般是指以货币形式,购买他人的劳动或劳动产品的,在一定区域或一定时期的专属权、所有权、经营权。

    5、保底加分成:保底分成保底分成的意思举例:我与网站签订合同,千字100元,如果这月我更新十万字,就是一万块。如果这个月这本书的销售超过一万块,达到了两万,那么我就可以拿到两万。如果低于一万,只有五千,那么我依然拿一万。这就是保底分成。

    6、加盟合作:加盟就是该企业组织,或者说加盟连锁总公司与加盟店二者之间的持续契约的关系。根据契约,必须提供一项独特的商业特权,并加上(人员培训、组织结构、经营管理、商品供销)的方面的无条件协助。而加盟店也需付出相对的报偿。

    023b5bb5c9ea15ce7b2a2b2fbb003af33b87b2d4.jpg

    二、五种合作方式

    (1)项目与项目的合作;

    (2)项目与人的合作;

    (3)项目与技术的合作;

    (4)项目与资金的合作;

    (5)项目与社会资源的合作。

     

     

     

     

     

     

    扩展资料:

    企业合作 (BusinessCooperation) 是指不同的企业之间通过协议或其他联合方式共同开发产品或市场,共享利益,以获取整体优势的经营活动

    当今具有代表性的企业间合作形式有:企业合作网络、战略联盟、供需链管理、企业集团等。

     

    企业合作网络就是将企业和经济组织间相互依赖的活动关系看作是一种企业网络,而各种从事这类活动的经济行为者就是网络中的节点。

    处于企业网络中的企业间的互动将不是通过市场交易,也不是通过企业的内部一体化过程,而是通过组织间的彼此协调来完成。企业可以通过网络来获得资源,使自己有可能克服自身的局限,实现企业的经营目标。

     

    战略联盟又称策略联盟,它是两个乃至多个企业或经济组织之间为了达到某种战略目的,通过某种契约或者部分股权关系而形成的一种合作形式。

    战略联盟的主体对象十分广泛,它不仅包括企业通常意义上的合作实体,如互补意义上的生产商、科研院所、政府部门、供应商、上下游企业等,还可能包括对手企业。战略联盟的主体之间的合作,有时是全面的,但更多的时候是基于某一特定的目的,在某一方面所进行的合作。

     

    供需链管理实际上是一个企业与其供应商、供应商的供应商,依次向前直到最初的供应商,以及与其销售商、销售商的销售商,按此向后直到最终用户之间的关系网链。供需链管理是市场渠道各层之间的一个联结,是控制供需链中从原材料通过各制造和分销商直到最终用户的一种管理思想和技术。

     

    企业集团是多个法人企业通过一定纽带,具有多个层次的,并允许跨行业、跨部门、跨所有制、跨国所组成的大型经济联合组织。企业集团的形成有两种途径,一是由一家大企业裂变而成,二是由两个以上的企业通过合作形成一个多法人企业。

    企业集团是为了进一步提高企业合作的效率而产生的,它是出于将外部合作内部化的目的,寻求一个在企业联合体内部完成企业间合作的过程。

     

    业务外包所推崇的理念是,如果我们在企业价值链的某一环节上不是世界上最好的,如果这又不是我们的核心竞争优势,如果这种活动不至于把我们同客户分开,那么我们应当把它外包给世界上最好的专业公司去做。

    也就是说,首先要确定企业的核心竞争优势,并把企业内部的智能和资源集中在那些具有核心竞争优势的活动上;然后将剩余的其他企业活动外包给最好的专业公司。

     

    所谓虚拟企业是指在有限资源的条件下,为取得最大的竞争优势,企业以自己拥有的优势产品或品牌为中心,由若干规模各异、拥有专长的小型企业或车间,通过信息网络和快速运输系统连接起来而组成的开放式组织形式。

    转载于:https://my.oschina.net/wuweixiang/blog/3063599

    展开全文
  • 这是我的设计模式作业:运用5个以上的设计模式创建一个系统。其中包括:1.单例模式 2.原型模式 3.抽象工厂模式+模板方法模式 4.代理模式 5.策略模式 详见博文:...
  • 我国融资租赁业还处于起步发展阶段,商业银行发展相对成熟,探讨两者的合作模式和前景具有现实意义。 按照我国《商业银行法》,商业银行不能直接办理融资租赁业务。但商业银行可以通过合作的方式介入融资租赁业务,...

    商业银行+融资租赁

    商业银行与融资租赁公司(包括金融机构和非金融机构)是比较典型的“合作+竞争”关系。对商业银行而言,融资租赁是企业获得融资的另一重要渠道,与银行信贷存在替代和竞争关系;同时融资租赁公司自己也需要商业银行的服务,在授信、中间业务等方面有着广阔的合作空间。我国融资租赁业还处于起步发展阶段,商业银行发展相对成熟,探讨两者的合作模式和前景具有现实意义。

    按照我国《商业银行法》,商业银行不能直接办理融资租赁业务。但商业银行可以通过合作的方式介入融资租赁业务,能够扩展市场,借助租赁公司强化在产业链条中的竞争优势。融资租赁公司缺乏稳定的资金来源,缺少网络化的分支机构,难以在跨行政区域方面形成网络效应,通过与商业银行的合作,实现更好的发展。现阶段,商业银行与融资租赁公司之间的合作,主要在以下三个方面:1、客户与金融产品的共享通用方面的合作,2、境内人民币融资方面的合作,3、国际业务方面的合作。

    一、客户与金融产品的共享通用方面的合作

    1、银行推荐客户,并提供结算等服务的模式

    是指银行向租赁公司推荐有租赁需求的客户,由租赁公司独立作出业务决策,银行在应收租赁款归集、资金账户监管提供服务,双方还可约定租后管理合作事宜。这种模式涉及的风险较低,执行的难度较低。

    2、租赁公司推荐客户,银行协助管理的模式

    是指租赁公司与银行签署合作协议,租赁公司将其直接营销的客户,统一到合作银行开设结算账户,由银行提供租赁款归集服务,或者还提供账户监管和租后管理等服务。这种模式涉及的风险也较低,执行的难度也较低。

    二、内人民币融资方面的合作

    1、租赁公司推荐客户,银行提供保理服务的模式

    是指租赁公司向银行推荐已完成的租赁项目和客户给银行,银行基于对承租人的授信或者租赁公司提供的增信,提供应收租赁款的保理服务。这种保理既包括对售后回租的保理,也包括直接租赁等其他租赁形式的保理。这种模式下,银行承担信用风险,要在给予承租人的授信条件和额度内合作,或在租赁公司提供的增信措施的授信条件和额度内合作。

    2、租赁公司推荐客户,银行提供结构化保理服务的模式

    是指租赁公司向银行推荐尚未完成资金交付的租赁项目和客户给银行,银行基于对租赁合同认可,视“未完成租金”为“已完成租金”,进行保理。这种模式主要是商业银行基于租赁公司营销的优质项目而进行的合作。这种模式下,银行承担信用风险,一般要在对承租人进行主体评级授信基础上,还要对融资租赁项目进行债项评级授信,两个评级授信都符合银行要求的情况下,才可开展合作。

    3、联合营销,杠杆租赁的模式

    是指银行和租赁公司配合,对于具有综合金融需求的优质客户或大项目釆取杠杆租赁的模式。杠杆租赁的做法类似银团贷款,由牵头的融资租赁公司出资拟购买租赁物价值的20%-40%,其余资金由商业银行提供,出租人需将设备的所有权、租赁合同和收取租金的权利抵押给银行。这种模式下,租赁公司可以享受到国家对购买设备的税收优惠。银行的风险控制类似于项目融资,要融资项目的债项评级优秀,才可开展合作。

    4、银行发行理财产品,对接融资应收租赁收益权模式

    是指租赁公司与银行合作、信托公司三方合作,由银行发行理财产品购买租赁公司的应收租金收益权。这种对接对应的,既可以是新租赁业务,也可以是存量租赁业务。这种模式的好处是作为表外资产进行管理,不占用商业银行的信贷规模。

    三、国际业务方面的合作

    在国际业务方面,商业银行可以为融资租赁公司提供更多的服务,传统的比如国际结算、结售汇、外汇衍生品等。创新的合作是内保外贷和内保内贷两种模式。

    1、内保外贷的模式

    该模式是指境外金融机构以银行开出的融资性保函为担保条件,向境内注册的外资租赁公司发放外债贷款,租赁公司再与境内用款客户办理租赁融资/售后回租业务。这种模式的好处在于借用外资租赁公司的外债额度从境外融资为境内用款客户获得低成本资金。这种模式要符合国家外汇管制的要求,境内注册的外资租赁公司有足够的外汇规模,商业银行要有对开证申请人的授信额度。

    2、内保内贷的模式

    该模式在内保外贷基础上发展而来,由商业银行根据境内企业申请,为其向境外银行开出融资性保函或备用信用证,境外银行据此向境内企业提供境外人民币融资的业务。该业务有利于申请人利用境外融资成本低的人民币资金,降低融资成本。这种模式要在境外人民币利率相对较低的情况下可行,商业银行要有对开证申请人的授信额度。

    信托公司+融资租赁

    在融资租赁业中,能够发行信托产品,可以在一定程度上有效缓解公司来自各方的资金压力。由此,融资租赁与信托的合作成为不少企业家的现实选择之一。

    一、信托公司自主管理的集合资金信托模式

    信托公司通过发行集合资金信托计划将信托资金集合起来,对信托资金进行专业化管理、运用,以融资租赁的形式购买设备,租赁给承租人使用,并收取租金。在这种交易模式下,信托投资公司既是出租人,又是加入信托计划的每一位委托人的受托人,即信托财产的管理人,通过自主管理购买租赁标的物,再租给承租人,达到投资者获取稳定信托收益的目的。

    二、银信合作主动管理融资租赁单一信托计划模式

    信托公司与商业银行合作,借助商业银行客户资源和资金平台,由商业银行发行理财产品,将募集的资金委托信托公司设立融资租赁单一信托计划,由信托公司对资金进行专业化管理、运用,以融资租赁的形式购买设备,租赁给承租人使用,并收取租金,使投资者获取稳定信托收益。

    三、信托公司与租赁公司合作模式

    1、融资租赁集合信托模式

    信托公司与租赁公司合作,借助租赁公司的项目资源、专业管理经验,信托公司发行融资租赁集合信托计划,在资金运用上由信托公司将资金贷给租赁公司用于购买设备,租赁给承租人使用并收取租金,以达到投资者获取稳定信托收益的目的。

    2、租赁资产收益权受让集合信托模式

    租赁公司为了盘活资产,可将一个或多个租赁项目未来的租金收入形成租赁资产的收益权进行转让,信托公司通过发行租赁资产收益权受让集合信托计划,以信托资金受让该租赁资产的收益权,信托期满后,由租赁公司溢价回购租赁资产的收益权,获取信托收益。

    四、信托公司与银行、第三方、租赁公司合作模式

    1、融资租赁单一信托模式

    此种模式下,租赁公司主要是由银行或有实力的第三方指定。通过信托公司与商业银行或第三方合作,借助第三方客户资源和资金平台,由商业银行发行融资租赁理财产品,将募集资金委托给信托公司,设立融资租赁单一资金信托计划。信托公司将资金贷给租赁公司,租赁公司用借款资金购买设备,租赁给承租人并收取租金,获取稳定信托收益。

    2、租赁资产收益权受让单一信托模式

    租赁公司为了盘活资产,可将一个或多个租赁项目未来的租金收入形成租赁资产收益权对外转让,由商业银行发行租赁资产收益权理财产品,募集的资金委托信托公司设立租赁资产收益权单一信托计划,以信托资金受让该租赁资产的收益权,信托期满后,由租赁公司溢价回购租赁资产收益权,获取稳定信托收益。

    五、租赁资产证券化模式

    信贷资产证券化是由中国境内的银行业金融机构或有实力的第三方委托有实力的银行等作为发起机构,将信贷资产信托给受托机构,由信托公司作为受托机构,以资产支持证券的形式向投资机构发行收益证券,以该财产所产生的现金支付资产支持证券的结构性融资活动。

    从未来的发展看,随着融资租赁公司的发展,当租赁资产能在未来产生可预的、稳定的现金流,就资产制定有标准化、高质量的合同条款,就具备了开展租赁资产证券化的条件。目前,随着信贷资产证券化试点的扩大,信托公司正在探索开展租赁资产证券化业务。

    券商+融资租赁

    作为likeqiangzonli口中的“新高地”,融资租赁业务在证券业悄然走俏,成为不少券商发力攻克的新方向。海通证券、光大证券、国泰君安等券商相继布局了融资租赁业。综合来看,券商布局融资租赁业务主要有两种方式,一是收购成熟的租赁公司,二是新设立融资租赁公司。

    一、收购

    2014年,海通证券斥资7.15亿美元收购香港恒信金融集团,通过收购成熟租赁公司,2014年上半年顺利完成恒信租赁股权交割的海通证券已经率先尝到了甜头。在海通证券2014年三季报中,其利息净收入为25.8亿,同比增长52%,对新增收入的贡献率达到30%,主要就是因恒信金融集团租赁收入并表所致。
    公司对新收购的租赁公司非常重视,前两个月投资银行部已有业务骨干被调派到恒信租赁开展工作,以期形成资源整合共享,进一步发挥综合金融平台的优势。海通证券和恒信租赁之间的合作主要表现在行业资源的分享,项目的相互推荐,潜在拟上市客户的导入等。

    二、设立

    国泰君安投资管理股份有限公司在上海自贸区设立了国泰君安融资租赁(上海)有限公司。该公司是由国泰君安投管公司控股、与卓杰亚太投资有限公司共同出资组建的一家中外合资融资租赁公司,注册资本1.8亿元人民币,并已于2014年底正式挂牌营业。国泰君安投管公司与国泰君安证券系出同源,于2001年底从国泰君安证券分立而出,主要股东为上海国有资产经营有限公司、中央汇金公司等大型企业。
    与市场上主流的银行系金融租赁公司、大型实业企业创办的融资租赁公司等不同的是,券商新设融资租赁公司的定位就是做有特色的券商系融资租赁公司,通过跟资本市场形成业务联动互补,进一步丰富综合金融服务的内涵。

    1、服务于券商

    最近融资融券等资本中介业务的火爆,让不少券商有资产出表的需求。利用融资租赁业务帮助证券公司改善资产负债表。具体方式是券商将信息技术设备、通信设备等固定资产出售回租,以获得一定的融资,而这些设备3~5年的生命周期也正好与融资租赁周期相匹配。在市场行情理想期间,不少证券公司都加大了对于信息技术设备的投入,而市场行情回落时,通过融资租赁方式帮助证券公司部分固定资产出表,获取资金成为业内青睐的一种模式。

    2、服务于企业客户

    券商系融资租赁公司更广阔的业务空间仍在于服务证券公司的企业客户,面向不同行业属性、经营规模、成长阶段的企业需求,以融资租赁带动多板块、全方位的金融服务,为企业提供贯穿成长周期的“一站式”解决方案。具体而言,针对初创型企业,可以通过租投结合,降低融资门槛,实现合作共赢;对于成长期企业,在已开展租赁业务的基础上,提供风险投资、并购重组、财务顾问等服务,助力企业从多层次资本市场中获取更丰富的发展资源;对于大型优质客户,则能利用租债联动、保理协同,帮助企业整合产业链资金流、盘活存量资产、优化税负和资产负债结构。
    希望发挥产融结合优势,将租赁公司与证券公司综合金融平台实现对接,提高投融资及其他金融增值业务服务能力。

    3、服务于新三板和准三板中小企业

    券商系融资租赁公司的一大目标客户为已在新三板挂牌的中小企业和准三板中小企业,通过融资租赁业务不但可以解决企业的资金融通问题,而且可以帮助企业调整报表,使企业在资本市场上更有竞争力,便于日后的三板挂牌或IPO。国泰君安融资租赁公司也有在“新三板”中掘金的规划举措。公司与一些机构进行接触合作,为证券公司手中较好的“新三板”标的提供服务,双方共同扶持企业成长,具体操作方式有几种:比如有证券公司客户急需短期借款,融资租赁公司可以通过商业保理给他们做短期融资,这样就完善了证券公司业务服务功能。又比如企业需要购买设备进行扩大再生产,融资租赁公司可以通过租投结合进行补位。对于核心的证券公司客户,可以通过1+n的供应链金融模式,为核心企业的上下游提供金融服务。

    保险公司+融资租赁

    2013年5月14日,平安租赁与平安资产管理有限责任公司在上海签署了合作备忘录,首期融资规模5亿元,这是中国融资租赁行业首次引入保险资金,此后,险资租入成为保险公司与融资租赁公司合作的主要模式。险资入租以后,不仅将拓宽租赁公司的融资渠道,也会改善整个融资租赁行业的负债结构。

    目前中国融资租赁公司的融资渠道较为单一,主要依靠银行贷款以及少量金融市场上衍生产品,融资规模有限,较容易受到中国宏观货币政策的影响。而且融资租赁公司的资产负债期限与银行间融资期限并不匹配,融资租赁公司投放的项目90%以上为3年期以上项目,但银行给予的融资一般为1-3年期。此次平安租赁引入长期限的保险资金,对于改善整个融资租赁行业的负债结构能起到良好的标杆作用。另一方面,险资入租也为保险资金拓宽了运用领域和投资渠道,优化了资产配置结构,可谓达到了“双赢”。而且,从成本优势来看,保险资金相对于其他短期资金,要求的投资收益相对不高,保险资金投资追求的是长期稳定的收益,而租赁公司的业务特点决定它正是需要长期稳定的资金。

    长期以来,保险资金一直是融资租赁业最青睐的融资渠道之一,保险先收后付的投资需求与租赁先付后收的资金需求,具有良好协同关系,但受政策限制,一直不得其门而入。受益于保监会对保险资金投资渠道的放宽,平安租赁积极开展与各方沟通,通过平安资管牵头,多家保险公司共同参与,利用保险资金投资租赁资产的创新交易结构,最终完成首单保险资金与融资租赁行业的成功对接。

    首次次险资入租的合作模式为,平安资管管理的保险资金通过投资信托计划的形式向平安租赁发放信托贷款。本次融入资金将主要用于日常经营周转,包括各类融资租赁项目的投放,主要覆盖健康卫生、制造加工、教育文化和公用事业等行业,为医疗机构、教育机构、公交水务、中小企业等各类企事业单位提供融资租赁服务。

    展开全文
  • 设计模式之适配器模式

    千次阅读 2022-01-22 21:18:31
    适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。 在适配器模式中,我们通过增加一个新的适配器类来解决接口不兼容的问题,使得原本没有任何关系的类可以协同工作。 根据适配器类与适配者类的关系不同...

    定义

    将一个接口转换成客户希望的另一个接口,使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。
    在适配器模式中,我们通过增加一个新的适配器类来解决接口不兼容的问题,使得原本没有任何关系的类可以协同工作。

    根据适配器类与适配者类的关系不同,适配器模式可分为对象适配器和类适配器两种,在对象适配器模式中,适配器与适配者之间是关联关系;在类适配器模式中,适配器与适配者之间是继承(或实现)关系。

    类型

    结构型

    分类
    具体又可以划分为类适配器、对象适配器。

    角色

    • 目标抽象类:Target,该角色把其他类转换为我们期望的接口,可以是一个抽象类或接口,也可以是具体类。
    • 被适配者: Adaptee ,原有的接口,也是希望被适配的接口。
    • 适配器: Adapter, 将被适配者和目标抽象类组合到一起的类。

    缺省适配器模式(Default Adapter Pattern):当不需要实现一个接口所提供的所有方法时,可先设计一个抽象类实现该接口,并为接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可以选择性地覆盖父类的某些方法来实现需求,它适用于不想使用一个接口中的所有方法的情况,又称为单接口适配器模式。缺省适配器模式是适配器模式的一种变体,其应用也较为广泛。在JDK类库的事件处理包java.awt.event中广泛使用了缺省适配器模式,如WindowAdapter、KeyAdapter、MouseAdapter等。

    类适配器和对象适配器

    类适配器

    被适配类:Adaptee

    public class Adaptee {
        public void adapterRequest(){
            System.out.println("被适配者的方法");
        }
    }
    

    目标抽象:Target接口

    public interface Target {
        void request();
    }
    

    怎么才可以在目标接口中的 request() 调用 Adaptee 的 adapteeRequest() 方法呢?

    如果直接实现 Target 是不行的,还是调用不到被适配类的方法

    ConcreteTarget类,具体目标类,实现了Target接口。

    public class ConcreteTarget implements Target {
    	@Override
        public void request() {
            System.out.println("concreteTarget目标方法");
        }
    }
    

    如果通过一个适配器类,实现 Target 接口,同时继承了 Adaptee 类,然后在实现的 request() 方法中调用父类的 adapteeRequest() 即可实现

    public class Adapter extends Adaptee implements Target {
    	@Override
        public void request() {
            super.adapterRequest();
        }
    }
    

    Adapter类继承了Adaptee类,所以称为类适配器(通过继承来实现)

    应用层代码:

    public class Test {
        public static void main(String[] args) {
            Target target = new ConcreteTarget();
            target.request();
    
            Target adapterTarget = new Adapter();
            adapterTarget.request();
        }
    }
    
    

    输出
    在这里插入图片描述
    类适配器的大致结构图如下所示,目标接口定义规范,适配器类相当于多了一层包装,可以调用到被适配者的方法。但是具体去实现一个目标接口的实现类是不能接触到被适配者类的属性和方法的。这样我们即可在新接口 Target 中适配旧的接口或类,然后供别人使用。
    也就是说:我打个比方,有的人喜欢看电子档书籍,有的人喜欢看纸质档。
    但是已有的就只是电子档,所以我们要增加一个步骤(在这里就是增加一个新接口),把电子档的书籍打印成纸质书籍给别人使用。
    在这里插入图片描述

    对象适配器

    public class Adaptee {
        public void adapterRequest(){
            System.out.println("被适配者的方法");
        }
    }
    
    public interface Target {
        void request();
    }
    
    public class ConcreteTarget implements Target {
        public void request() {
            System.out.println("concreteTarget目标方法");
        }
    }
    

    前面的这些类和类适配器中的一样。

    对象适配器与类适配器不同之处在于,类适配器通过继承来完成适配,对象适配器则是通过关联来完成,这里稍微修改一下 Adapter 类即可将转变为对象适配器,把被适配者Adaptee关联进入适配器类Adapter

    public class Adapter implements Target {
        private Adaptee adaptee = new Adaptee();
    
        public void request() {
            adaptee.adapterRequest();
        }
    }
    
    

    测试:

    public class Test {
        public static void main(String[] args) {
            Target target = new ConcreteTarget();
            target.request();
    
            Target adapterTarget = new Adapter();
            adapterTarget.request();
        }
    }
    

    输出
    在这里插入图片描述
    结果一样,只是Adapter类与Adaptee类的关系不同而已(一个是继承,一个是组合)。(Adapter类与Adaptee类在这里是组合关系,两个生命周期一致)
    在这里插入图片描述

    示例

    我们平时用充电器给手机充电,充电器可能需要将220v的电压转换成5v的电压,我们才能给手机正常充电。

    AC220类(Adaptee),被适配者类,原有220v的电压。

    public class AC220 {
        public int outputAC220V(){
            int output = 220;
            System.out.println("输出交流电"+output+"V");
            return output;
        }
    }
    
    

    DC5类(Target接口),目标接口,需要转换成5v的电压。

    public interface DC5 {
        int outputDC5V();
    }
    

    PowerAdapter类(Adapter类),适配器类,将220v的电压转换成5v的电压。

    public class PowerAdapter implements DC5 {
        private AC220 ac220 = new AC220();
    
        public int outputDC5V() {
            int adapterInput = ac220.outputAC220V();
    
            //变压器...
            int adapterOutput = adapterInput/44;
    
            System.out.println("使用PowerAdapter输入AC"+adapterInput+"V"+"输出DC"+adapterOutput+"V");
            return adapterInput;
        }
    }
    
    

    应用层代码:

    public class Test {
        public static void main(String[] args) {
            DC5 dc5 = new PowerAdapter();
            dc5.outputDC5V();
        }
    }
    

    输出:
    在这里插入图片描述
    类图如下
    在这里插入图片描述

    具体应用

    JDK代码中的适配器模式

    StringReader
    里面组合了String 实例,来给别人调用

    import java.io.IOException;
    import java.io.Reader;
    
    public class StringReader extends Reader {
    
        private String str;
        private int length;
        private int next = 0;
        private int mark = 0;
    
    
        public StringReader(String s) {
            this.str = s;
            this.length = s.length();
        }
    
        //确认该流没有被关闭
        private void ensureOpen() throws IOException {
            if (str == null)
                throw new IOException("Stream closed");
        }
    
        // 读取字符
        public int read() throws IOException {
            synchronized (lock) {
                ensureOpen();
                if (next >= length)
                    return -1;
                return str.charAt(next++);
            }
        }
    
        // 读取字符数组中的字符
        public int read(char cbuf[], int off, int len) throws IOException {
            synchronized (lock) {
                ensureOpen();
                if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                    ((off + len) > cbuf.length) || ((off + len) < 0)) {
                    throw new IndexOutOfBoundsException();
                } else if (len == 0) {
                    return 0;
                }
                if (next >= length)
                    return -1;
                int n = Math.min(length - next, len);
                str.getChars(next, next + n, cbuf, off);
                next += n;
                return n;
            }
        }
    
        // 跳转
        public long skip(long ns) throws IOException {
            synchronized (lock) {
                ensureOpen();
                if (next >= length)
                    return 0;
                // Bound skip by beginning and end of the source
                long n = Math.min(length - next, ns);
                n = Math.max(-next, n);
                next += n;
                return n;
            }
        } 
    
        // 确认该字符是否已被读取
        public boolean ready() throws IOException {
            synchronized (lock) {
            ensureOpen();
            return true;
            }
        }
    
        // 是否支持mark操作
        public boolean markSupported() {
            return true;
        }
    
        //标识当前位置
        public void mark(int readAheadLimit) throws IOException {
            if (readAheadLimit < 0){
                throw new IllegalArgumentException("Read-ahead limit < 0");
            }
            synchronized (lock) {
                ensureOpen();
                mark = next;
            }
        }
    
        // 重置当前位置
        public void reset() throws IOException {
            synchronized (lock) {
                ensureOpen();
                next = mark;
            }
        }
    
        // 关闭流
        public void close() {
            str = null;
        }
    }
    

    StringWriter
    里面组合了StringBuffer,来给别人使用

    import java.io.IOException;
    import java.io.Writer;
    
    public class StringWriter extends Writer {
    
        private StringBuffer buf;
    
    
        public StringWriter() {
            buf = new StringBuffer();
            lock = buf;
        }
    
        public StringWriter(int initialSize) {
            if (initialSize < 0) {
                throw new IllegalArgumentException("Negative buffer size");
            }
            buf = new StringBuffer(initialSize);
            lock = buf;
        }
    
        // 写入字符
        public void write(int c) {
            buf.append((char) c);
        }
    
        // 写入数组中的字符
        public void write(char cbuf[], int off, int len) {
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return;
            }
            buf.append(cbuf, off, len);
        }
    
        //写入字符串
        public void write(String str) {
            buf.append(str);
        }
    
        // 在指定位置写入字符串
        public void write(String str, int off, int len)  {
            buf.append(str.substring(off, off + len));
        }
    
        // 增加字符串序列
        public StringWriter append(CharSequence csq) {
            if (csq == null)
                write("null");
            else
                write(csq.toString());
            return this;
        }
    
        // 在指定位置增加字符串序列
        public StringWriter append(CharSequence csq, int start, int end) {
            CharSequence cs = (csq == null ? "null" : csq);
            write(cs.subSequence(start, end).toString());
            return this;
        }
    
        // 增加字符
        public StringWriter append(char c) {
            write(c);
            return this;
        }
    
        public String toString() {
            return buf.toString();
        }
    
        public StringBuffer getBuffer() {
            return buf;
        }
    
        public void flush() {
        }
    
    
        public void close() throws IOException {
        }
    }
    

    spring AOP中的适配器模式

    在Spring的Aop中,使用的 Advice(通知) 来增强被代理类的功能。

    Advice的类型有:MethodBeforeAdvice、AfterReturningAdvice、ThrowsAdvice

    在每个类型 Advice 都有对应的拦截器,MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor、ThrowsAdviceInterceptor

    Spring需要将每个 Advice 都封装成对应的拦截器类型,返回给容器,所以需要使用适配器模式对 Advice 进行转换

    三个被适配者 如下:

    public interface MethodBeforeAdvice extends BeforeAdvice {
        void before(Method var1, Object[] var2, @Nullable Object var3) throws Throwable;
    }
    
    public interface AfterReturningAdvice extends AfterAdvice {
        void afterReturning(@Nullable Object var1, Method var2, Object[] var3, @Nullable Object var4) throws Throwable;
    }
    
    public interface ThrowsAdvice extends AfterAdvice {
    }
    

    目标接口 Target,有两个方法,一个判断 Advice 类型是否匹配,一个是工厂方法,创建对应类型的 Advice 对应的拦截器

    public interface AdvisorAdapter {
        boolean supportsAdvice(Advice var1);
    
        MethodInterceptor getInterceptor(Advisor var1);
    }
    
    

    三个适配器类分别如下,注意其中的 Advice、Adapter、Interceptor之间的对应关系

    class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
    	@Override
    	public boolean supportsAdvice(Advice advice) {
    		return (advice instanceof MethodBeforeAdvice);
    	}
    
    	@Override
    	public MethodInterceptor getInterceptor(Advisor advisor) {
    		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
    		return new MethodBeforeAdviceInterceptor(advice);
    	}
    }
    
    @SuppressWarnings("serial")
    class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {
    	@Override
    	public boolean supportsAdvice(Advice advice) {
    		return (advice instanceof AfterReturningAdvice);
    	}
    	@Override
    	public MethodInterceptor getInterceptor(Advisor advisor) {
    		AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
    		return new AfterReturningAdviceInterceptor(advice);
    	}
    }
    
    class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {
    	@Override
    	public boolean supportsAdvice(Advice advice) {
    		return (advice instanceof ThrowsAdvice);
    	}
    	@Override
    	public MethodInterceptor getInterceptor(Advisor advisor) {
    		return new ThrowsAdviceInterceptor(advisor.getAdvice());
    	}
    }
    
    

    客户端 DefaultAdvisorAdapterRegistry

    public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
        private final List<AdvisorAdapter> adapters = new ArrayList(3);
    
        public DefaultAdvisorAdapterRegistry() {
            // 这里注册了适配器
            this.registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
            this.registerAdvisorAdapter(new AfterReturningAdviceAdapter());
            this.registerAdvisorAdapter(new ThrowsAdviceAdapter());
        }
        
        public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
            List<MethodInterceptor> interceptors = new ArrayList(3);
            Advice advice = advisor.getAdvice();
            if (advice instanceof MethodInterceptor) {
                interceptors.add((MethodInterceptor)advice);
            }
    
            Iterator var4 = this.adapters.iterator();
    
            while(var4.hasNext()) {
                AdvisorAdapter adapter = (AdvisorAdapter)var4.next();
                if (adapter.supportsAdvice(advice)) {   // 这里调用适配器方法
                    interceptors.add(adapter.getInterceptor(advisor));  // 这里调用适配器方法
                }
            }
    
            if (interceptors.isEmpty()) {
                throw new UnknownAdviceTypeException(advisor.getAdvice());
            } else {
                return (MethodInterceptor[])interceptors.toArray(new MethodInterceptor[0]);
            }
        }
        // ...省略...
    }    
    
    

    这里看 while 循环里,逐个取出注册的适配器,调用 supportsAdvice() 方法来判断 Advice 对应的类型,然后调用 getInterceptor() 创建对应类型的拦截器
    在这里插入图片描述
    这里应该属于对象适配器模式,关键字 instanceof 可看成是 Advice 的方法,不过这里的 Advice 对象是从外部传进来,而不是成员属性

    spring JPA中的适配器模式

    在Spring的ORM包中,对于JPA的支持也是采用了适配器模式,首先定义了一个接口的 JpaVendorAdapter,然后不同的持久层框架都实现此接口。

    jpaVendorAdapter:用于设置实现厂商JPA实现的特定属性,如设置Hibernate的是否自动生成DDL的属性generateDdl;这些属性是厂商特定的,因此最好在这里设置;目前Spring提供 HibernateJpaVendorAdapter、OpenJpaVendorAdapter、EclipseLinkJpaVendorAdapter、TopLinkJpaVendorAdapter 四个实现。其中最重要的属性是 database,用来指定使用的数据库类型,从而能根据数据库类型来决定比如如何将数据库特定异常转换为Spring的一致性异常,目前支持如下数据库(DB2、DERBY、H2、HSQL、INFORMIX、MYSQL、ORACLE、POSTGRESQL、SQL_SERVER、SYBASE)

    JpaVendorAdapter接口

    public interface JpaVendorAdapter
    {
      // 返回一个具体的持久层提供者
      public abstract PersistenceProvider getPersistenceProvider();
    
      // 返回持久层提供者的包名
      public abstract String getPersistenceProviderRootPackage();
    
      // 返回持久层提供者的属性
      public abstract Map<String, ?> getJpaPropertyMap();
    
      // 返回JpaDialect
      public abstract JpaDialect getJpaDialect();
    
      // 返回持久层管理器工厂
      public abstract Class<? extends EntityManagerFactory> getEntityManagerFactoryInterface();
    
      // 返回持久层管理器
      public abstract Class<? extends EntityManager> getEntityManagerInterface();
    
      // 自定义回调方法
      public abstract void postProcessEntityManagerFactory(EntityManagerFactory paramEntityManagerFactory);
    }
    
    

    我们来看其中一个适配器实现类 HibernateJpaVendorAdapter

    public class HibernateJpaVendorAdapter extends AbstractJpaVendorAdapter {
        //设定持久层提供者
        private final PersistenceProvider persistenceProvider;
        //设定持久层方言
        private final JpaDialect jpaDialect;
    
        public HibernateJpaVendorAdapter() {
            this.persistenceProvider = new HibernatePersistence();
            this.jpaDialect = new HibernateJpaDialect();
        }
    
        //返回持久层方言
        public PersistenceProvider getPersistenceProvider() {
            return this.persistenceProvider;
        }
    
        //返回持久层提供者
        public String getPersistenceProviderRootPackage() {
            return "org.hibernate";
        }
    
        //返回JPA的属性
        public Map<String, Object> getJpaPropertyMap() {
            Map jpaProperties = new HashMap();
    
            if (getDatabasePlatform() != null) {
                jpaProperties.put("hibernate.dialect", getDatabasePlatform());
            } else if (getDatabase() != null) {
                Class databaseDialectClass = determineDatabaseDialectClass(getDatabase());
                if (databaseDialectClass != null) {
                    jpaProperties.put("hibernate.dialect",
                            databaseDialectClass.getName());
                }
            }
    
            if (isGenerateDdl()) {
                jpaProperties.put("hibernate.hbm2ddl.auto", "update");
            }
            if (isShowSql()) {
                jpaProperties.put("hibernate.show_sql", "true");
            }
    
            return jpaProperties;
        }
    
        //设定数据库
        protected Class determineDatabaseDialectClass(Database database)     
        {                                                                                       
            switch (1.$SwitchMap$org$springframework$orm$jpa$vendor$Database[database.ordinal()]) 
            {                                                                                     
            case 1:                                                                             
              return DB2Dialect.class;                                                            
            case 2:                                                                               
              return DerbyDialect.class;                                                          
            case 3:                                                                               
              return H2Dialect.class;                                                             
            case 4:                                                                               
              return HSQLDialect.class;                                                           
            case 5:                                                                               
              return InformixDialect.class;                                                       
            case 6:                                                                               
              return MySQLDialect.class;                                                          
            case 7:                                                                               
              return Oracle9iDialect.class;                                                       
            case 8:                                                                               
              return PostgreSQLDialect.class;                                                     
            case 9:                                                                               
              return SQLServerDialect.class;                                                      
            case 10:                                                                              
              return SybaseDialect.class; }                                                       
            return null;              
        }
    
        //返回JPA方言
        public JpaDialect getJpaDialect() {
            return this.jpaDialect;
        }
    
        //返回JPA实体管理器工厂
        public Class<? extends EntityManagerFactory> getEntityManagerFactoryInterface() {
            return HibernateEntityManagerFactory.class;
        }
    
        //返回JPA实体管理器
        public Class<? extends EntityManager> getEntityManagerInterface() {
            return HibernateEntityManager.class;
        }
    }
    
    

    配置文件中可以这样指定

    <bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"> 
       <property name="generateDdl" value="false" />  
       <property name="database" value="HSQL"/>  
    </bean>  
    <bean id="jpaDialect" class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>  
    
    

    spring MVC中的适配器模式

    Spring MVC中的适配器模式主要用于执行目标 Controller 中的请求处理方法。

    在Spring MVC中,DispatcherServlet 作为用户,HandlerAdapter 作为期望接口,具体的适配器实现类用于对目标类进行适配,Controller 作为需要适配的类。

    为什么要在 Spring MVC 中使用适配器模式?Spring MVC 中的 Controller 种类众多,不同类型的 Controller 通过不同的方法来对请求进行处理。如果不利用适配器模式的话,DispatcherServlet 直接获取对应类型的 Controller,需要的自行来判断,像下面这段代码一样:

    if(mappedHandler.getHandler() instanceof MultiActionController){  
       ((MultiActionController)mappedHandler.getHandler()).xxx  
    }else if(mappedHandler.getHandler() instanceof XXX){  
        ...  
    }else if(...){  
       ...  
    }  
    
    

    这样假设如果我们增加一个 HardController,就要在代码中加入一行 if(mappedHandler.getHandler() instanceof HardController),这种形式就使得程序难以维护,也违反了设计模式中的开闭原则 – 对扩展开放,对修改关闭。

    我们来看看源码,首先是适配器接口 HandlerAdapter

    public interface HandlerAdapter {
        boolean supports(Object var1);
    
        ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;
    
        long getLastModified(HttpServletRequest var1, Object var2);
    }
    
    

    现该接口的适配器每一个 Controller 都有一个适配器与之对应,这样的话,每自定义一个 Controller 需要定义一个实现 HandlerAdapter 的适配器。

    springmvc 中提供的 Controller 实现类有如下
    在这里插入图片描述

    springmvc 中提供的 HandlerAdapter 实现类如下
    在这里插入图片描述
    HttpRequestHandlerAdapter 这个适配器代码如下

    public class HttpRequestHandlerAdapter implements HandlerAdapter {
        public HttpRequestHandlerAdapter() {
        }
    
        public boolean supports(Object handler) {
            return handler instanceof HttpRequestHandler;
        }
    
        public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            ((HttpRequestHandler)handler).handleRequest(request, response);
            return null;
        }
    
        public long getLastModified(HttpServletRequest request, Object handler) {
            return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
        }
    }
    
    

    当Spring容器启动后,会将所有定义好的适配器对象存放在一个List集合中,当一个请求来临时,DispatcherServlet 会通过 handler 的类型找到对应适配器,并将该适配器对象返回给用户,然后就可以统一通过适配器的 hanle() 方法来调用 Controller 中的用于处理请求的方法。

    public class DispatcherServlet extends FrameworkServlet {
        private List<HandlerAdapter> handlerAdapters;
        
        //初始化handlerAdapters
        private void initHandlerAdapters(ApplicationContext context) {
            //..省略...
        }
        
        // 遍历所有的 HandlerAdapters,通过 supports 判断找到匹配的适配器
        protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    		for (HandlerAdapter ha : this.handlerAdapters) {
    			if (logger.isTraceEnabled()) {
    				logger.trace("Testing handler adapter [" + ha + "]");
    			}
    			if (ha.supports(handler)) {
    				return ha;
    			}
    		}
    	}
    	
    	// 分发请求,请求需要找到匹配的适配器来处理
    	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    		HttpServletRequest processedRequest = request;
    		HandlerExecutionChain mappedHandler = null;
    
    		// Determine handler for the current request.
    		mappedHandler = getHandler(processedRequest);
    			
    		// 确定当前请求的匹配的适配器.
    		HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
    		ha.getLastModified(request, mappedHandler.getHandler());
    					
    		mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        }
    	// ...省略...
    }	
    
    

    通过适配器模式我们将所有的 controller 统一交给 HandlerAdapter 处理,免去了写大量的 if-else 语句对 Controller 进行判断,也更利于扩展新的 Controller 类型。

    JUnit中的适配器模式

    通俗而言,就是要适配成TestCase类。这里重点看TestCase的runTest()方法:

    protected void runTest() throws Throwable {
            assertNotNull("TestCase.fName cannot be null", this.fName);
            Method runMethod = null;
            try {
                //获取要测试的方法
                runMethod = getClass().getMethod(this.fName, (Class[]) null);
            } 
            catch (NoSuchMethodException e) {
                fail("Method \"" + this.fName + "\" not found");
            }
            //判断要测试的方法是否为公用方法
            if (!Modifier.isPublic(runMethod.getModifiers())) {
                fail("Method \"" + this.fName + "\" should be public");
            }
            //java反射机制
            try {
                runMethod.invoke(this, new Object[0]);
            } 
            catch (InvocationTargetException e) {
                e.fillInStackTrace();
                throw e.getTargetException();
            } 
            catch (IllegalAccessException e) {
                e.fillInStackTrace();
                throw e;
            }
        }
    

    总结

    主要优点

    • 将目标类和适配者类解耦,通过引入一个适配器类来重用现有的适配者类,无须修改原有结构。
    • 增加了类的透明性和复用性,将具体的业务实现过程封装在适配者类中,对于客户端类而言是透明的,而且提高了适配者类的复用性,同一个适配者类可以在多个不同的系统中复用。
    • 灵活性和扩展性都非常好,通过使用配置文件,可以很方便地更换适配器,也可以在不修改原有代码的基础上增加新的适配器类,符合“开闭原则”。

    主要缺点

    • 会让系统看起来很复杂,不易维护(因为需要从全局考虑)
    • 增加代码的阅读难度

    适配器模式最好在详细设计不要考虑它,它不是为了解决还处在开发阶段的问题,而是解决正在服役的项目问题。

    适用场景

    想要使用一个已经存在的类,但是它却不符合现有的接口规范,导致无法直接去访问,这时创建一个适配器就能间接去访问这个类中的方法。
    我们有一个类,想将其设计为可重用的类,我们可以创建适配器,将这个类来适配其他没有提供合适接口的类。
    优点

    和其他模式的对比

    • 适配器模式和装饰者模式:装饰者模式是对以前的类进行进一步的封装与增强,目的是一层一层的增加功能,而适配器模式主要是为了协调多个调用者不同的调用方式而设计出来的。
    • 适配器模式和外观模式:都是对现有类的封装,外观模式定义了新的接口,适配器则是复用已有的接口,适配器是两个接口协调工作,而外观模式则是为了别人使用的方便,提供了一个比较易用的接口

    References:

    • https://whirlys.blog.csdn.net/article/details/82780560
    • https://blog.csdn.net/lu__peng/article/details/79117894
    • https://blog.csdn.net/liuquan0071/article/details/50506121

    这些东西其他博客都总结的非常好,我这里只是做了一点点修改与扩充,以后有了不同的理解我再进行补充完善。

    (写博客主要是对自己学习的归纳整理,资料大部分来源于书籍、网络资料和自己的实践,整理不易,但是难免有不足之处,如有错误,请大家评论区批评指正。同时感谢广大博主和广大作者辛苦整理出来的资源和分享的知识。)

    展开全文
  • git合作流程(collaborator模式和contributor模式

    千次阅读 多人点赞 2019-02-06 20:57:52
    前言:github的三种合作模式:1)fork;2)organization;3)collaborator,开发者在这三种模式下的权限依次升高。 合作者模式: 假设我们有两个合作者A和B共同开发维护一个代码仓库(repository),其中A是仓库的...
  • 软件盈利模式的思考

    千次阅读 2021-05-29 00:44:00
    软件有很多种形式来体现,因此其盈利模式也会多种多样。 很多软件盈利并不是技术牛,有些软件随着业务和收入迅速的发展而不断改进,采用新的架构和算法去解决各种问题。 1 基于附加业务运营的免费软件 使用软件本身...
  • 【前言】 鹅思晗小组三个菜鸟成就一个系统,在这个过程中我有幸负责BLL层和外观层的实现。...经过去年软考的洗礼,又对设计模式学习一遍,这次再次捡起机房用设计模式时觉得比当初理解要深许多。 今天小...
  • 产品的商业模式以及商业模式画布

    千次阅读 2018-09-22 11:52:39
    盈利模式VS 商业模式 相同点 广泛的讲,商业模式包含盈利模式 不同点 商业模式: 企业的商业逻辑,主要包括用户价、盈利模式、产品定位、核心资源等。商业模式的作用是明确这种模式是否在正确的方向和轨道上,...
  • 共享模式到底是什么

    千次阅读 2019-04-28 20:57:46
    在现有的共享模式下,有非常多成熟的商业应用,比如共享单车、共享充电宝、共享汽车、共享房屋、共享雨伞等等。我认为这些东西还仅仅停留在单个物品的层级,对于共享经济的定义还比较窄,大家可以发散的想一想,我们...
  • JavaScript设计模式

    千次阅读 多人点赞 2020-03-24 10:47:07
    **设计模式:**代码经验的总结,是可重用的用于解决软件设计中一般问题的方案。 设计模式都是面向对象的。 学习设计模式,有助于写出可复用和可维护性高的程序。 常用的12种设计模式: 工厂模式 单例模式 原型...
  • 数字孪生服务提供模式及典型案例

    千次阅读 2022-01-21 16:34:34
    数字孪生主流服务模式 国内外企业纷纷在数字孪生领域进行布局,数字孪生平台构建成为打造产业生态的关键。 目前主流的数字孪生服务模式可分为领域服务模式和通用服务模式。 一是领域服务模式。领域服务模式与具体的...
  • 在上篇文章中我们已经对OAuth2.0 做了讲解,以及授权码模式的认证过程,并且搭建了简单的认证服务和资源服务,由于上篇文章中我们只对授权码模式这一种认证登录模式做了讲解,本篇文章对简化模式、密码模式、客户端...
  • 商业模式画布

    万次阅读 多人点赞 2018-07-22 18:52:11
    周四周五机缘巧合参加了一场关于商业模式画布的培训,第一次参加趋向于商业方向的培训,一开始并没有抱太大的期望。但是听完两天的课之后,第一次给培训的老师全是满分的评价,因为确实内容非常受用,两天的课程中即...
  • Spring中所使用的设计模式

    万次阅读 多人点赞 2021-01-14 02:51:09
    Spring是一个非常优秀的开源框架,项目源码中所使用的设计模式随处可见,这篇文章主要记录一下Spring中常见的设计模式: (1)工厂模式:Spring使用工厂模式,通过BeanFactory和ApplicationContext来创建对象 (2...
  • 共享经济新模式——共享员工

    千次阅读 2020-02-14 23:30:34
    今天和大家聊聊在本次疫情之后,行业内催生的一种新的...乍一看,好像没什么,不就是A公司的员工通过借调或者外包的方式到B公司去上班,但是背后却凸显出了疫情危机之下行业用工、企业跨界合作的必要性和灵活性。...
  • 23种设计模式常用模式

    万次阅读 多人点赞 2018-08-08 09:14:41
    设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码...
  • 什么是商业模式(概念篇)

    千次阅读 2020-12-14 12:01:24
     用最直白的话告诉大家:商业模式就是公司通过什么途径或方式来赚钱?简言之,饮料公司通过卖饮料来赚钱;快递公司通过送快递来赚钱;网络公司通过点击率来赚钱;通信公司通过收话费赚钱;超市通过平台和仓储来赚钱...
  • 今年上半年,我国人力资源社会保障部正式下发了关于深入实施“人社服务快办行动”的...不久前,来也科技与东软集团签署人社行业战略合作协议,共同携手合作,旨在探索创新合作模式,让RPA+AI 技术更好地在社保场景落
  • 一、软件设计模式的产生背景 “设计模式”这个术语最初并不是出现在软件设计中,而是被用于建筑领域的设计中。 1977 年,美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大...
  • 单例模式详解(附常见的7种单例模式源码)

    千次阅读 多人点赞 2019-05-24 16:22:18
    单例模式(Singleton Pattern):保证一个类仅有一个对象,并提供一个访问它的全局访问点。(Ensure a class only has one instance,and provide a globe point of access to it.) 常见应用场景: Windows的Task ...
  • JavaScript设计模式之装饰者模式

    万次阅读 2019-12-08 23:56:07
    引:什么是装饰者模式 在传统的面向对象语言中,给对象添加功能常常使用继承的方式,但是继承的方式并不灵活,还会带来许多问题:一方面会导致超类和子类之间存在强耦合性,当超类改变时,子类也会随之改变;另一方面...
  • 【商业模式】这个词可以算是所有商业活动中的最高频词了,高频到成了我们“最熟悉的陌生人”,就像所有人都在说人工智能、区块链,但是真正理解的并不多。产品经理的行为本质上就是商业行为,所以“商业模式”将是我...
  • 设计模式学习之中介者模式

    千次阅读 2017-04-22 21:13:02
    我们平时写代码的过程,一个类必然会与其他类产生依赖关系,如果这种依赖关系如网状般错综复杂,那么必然会影响我们的代码逻辑以及执行效率,适当地使用中介者模式可以对这种依赖关系进行解耦使逻辑结构清晰,本篇...
  • 请务必备注:商务合作 二、CSDN侧边栏展示位 1、用户定位 由于博客文章主要面向Java开发人员,涵盖初级、中级和高级博文,每个界面均可显示侧边栏广告位,曝光率较高! 2、广告位示例 每一篇文章均会显示! ...
  • 开源软件的盈利模式

    千次阅读 2019-08-20 11:33:15
    开源软件与商业并不冲突,它是一种新兴的商业模式。与传统的商业软件相比,开源软件采用了开放源代码、免费分发等形式,减少了营销与销售成本,更易于广泛传播。 在开源软件领域中,常见的盈利模式一共有7种。下面...
  • 软件设计模式详解

    万次阅读 多人点赞 2018-11-07 21:40:21
    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 ...
  • 本文从总结的角度去学习23种设计模式去掉不应有的废话。适合复习阅读和部分初学者。
  • 这篇来介绍一下适配器模式(Adapter Pattern),适配器模式在开发中使用的频率也是很高的,像 ListView 和 RecyclerView 的 Adapter 等都是使用的适配器模式。在我们的实际生活中也有很多类似于适配器的例子,比如...
  • AutoSAR系列讲解(实践篇)10.1-模式管理概述

    万次阅读 多人点赞 2019-12-11 13:45:25
    模式管理做一个大致的介绍,顺便讲解一下其中很重要的BswM和EcuM

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 311,660
精华内容 124,664
关键字:

一般公司的合作模式