数据结构的题目如下,急用、、、、、1 定义一个汽车类（car）,至少包括构造函数,汽车行驶、停车等成员函数和型号、价格.重量、油耗、行驶速度等成员变量.2 将(1)中提到的成员变量定义为私有访问权限,将成员函数定义为共有访问权限.3 在主函数中定义三个汽车类的对象,并调用相关的成员函数.
米饭wan12701
#include#includeclass car{private://车型//重量//油耗//速度public:car(string style,float weight,float fconsum,float speed)//构造函数{this->style =this->weight =this->fconsum =this->speed =}void driving();//行驶void stop();//停车void printstyle();//输出车型};void car::driving(){cout
为您推荐：
其他类似问题
扫描下载二维码bearcat a POJOs based application framework for node.js - Pomelo Club
bearcat a POJOs based application framework for node.js
Bearcat是一个基于POJOs进行开发的应用层框架, Bearcat提供了一个轻量级的容器来编写简单，可维护的. Bearcat 提供了一个基础的底层来管理应用逻辑对象，使得开发者就可以把精力放在应用层的逻辑编写上. Bearcat 使开发者编写“简单纯粹的javaScript对象”(POJO), 并且不会侵入这些POJO，你完全可以在不使用Bearcat的环境下部署应用这些POJO.
Homepage: &;
Mailing list: &;
Issues: &;
Tags: nodejs, POJO, IoC, AOP, consistent configuration
Bearcat 概览
Bearcat 包括几个部分，包括：
核心容器包含核心，Beans，以及Context模块.
核心和Beans模块提供容器的基础部分，包含IoC容器和依赖注入. BeanFactory 是一个复杂的factory工厂模式实现. 它去除了手动去编写单例，允许你的实际程序逻辑从配置和依赖的管理中解偶.
Context 模块基于核心和Beans模块之上，并提供了一些更高级的内容，applicationContext 是它的主要实现.
面向切面编程
Bearcat 基于核心容器提供了面向切面编程(AOP)的支持, 允许开发者定义，方法拦截器，切面来解偶那些需要被分离的业务逻辑.
轻量级容器
* 依赖注入(DI)实现的控制反转(IoC)来管理POJOs* 基于AOP的声明横切逻辑* 一致的开发与配置
* 简单的元数据配置和编写POJOs* 轻量的: 基于node.js的高效率开发* 可重用的: POJOs 可以应用于任何开发环境* 无侵入的: 不依赖于容器API的开发* 模块化: 使用那些你需要的部分* 一站式服务: 没必要手动编写单例和工厂方法
* 良好的参考资料: 文档完整，很多实例包含 ,
* 良好的测试: 测试超过95%
* 自定义扩展: 可以为容器添加自定义的代码
更多请参考
10:07重新编辑
这个会和pomelo融合么？
我也想知道，这个和pomelo有什么关系么？
@ @ 可以结合bearcat来进行pomelo开发, bearcat 可以解决很多 pomelo 作为一个游戏框架所无法解决的问题, 比如配置, 依赖关系, 事务等等
请教如何使用这个实现事务？用哪个特性？
@ 事务看这个哈
@ 没用过JAVA，理解这些概念有点难懂，但能方面解决事务问题，pomelo就更强大了，谢！
@ 哈哈，概念差不多的，看看例子照着慢慢用起来
顶一下，虽不明但觉利
刚刚又重新看了一下，不知道我理解是否正确。
这个东东实际上就是一个存放全局变量（对象）的容器？而且这些全局变量的类型，名字，生成方法都是可以基于json配置的。用这个东西可以更好的管理对象，使用对象，通过配置达到一些解耦的效果。
但是我看了这个官方的例子又疑惑了：
module.exports = function(app) {
var bearcat = app.get(&bearcat&);
return bearcat.getBean({
id: &gateHandler&,
func: Handler,
name: &app&,
value: app
var Handler = function(app) {
this.app =
这段代码是想让这个handler可以复用对吧？但是我觉得其实没有解耦啊。第一，handler对象的生成依赖于app对象，添加到bearcat中也需要app对象第二，bearcat对象自己本身如何在多个js文件中共享呢？这个例子是通过放到pomelo的app里面的。如果一个拿不到app对象的js文件里面，如何使用bearcat中已有的bean呢？
再比如这个例子，其实car和engine还是耦合的，car怎么知道engine有run方法呢？使用bearcat得到car对象，怎么知道的car具有run方法呢？在我看来，所谓的通过配置来解耦，最终还是没有解耦。
用户想要使用car或者engine，还是必须得去看car和engine的源代码...... 使用bearcat和我们平时写的代码的区别就是可以从bearcat取出对象而已。不知道我这样理解是否正确？
// the Car has a dependency on an Engine
// a constructor so that the Bearcat container can inject an Engine
var Car = function(engine) {
this.engine =
Car.prototype.run = function() {
console.log(&run car...&);
this.engine.run();
module.exports = C
var Engine = function() {}
Engine.prototype.run = function() {
console.log(&run engine...&);
module.exports = E
context.json
&name&: &simple_inject_args&,
&beans&: [{
&id&: &car&,
&func&: &car&,
&args&: [{
&name&: &engine&,
&ref&: &engine&
&id&: &engine&,
&func&: &engine&
@这里我简单回答一下哈： 1：第一个例子这么写，是因为pomelo里面的handler,remote是通过pomelo-loader管理加载的,bearcat要切入进来就需要一个proxy，这里通过bearcat.getBean返回了一个proxy，这个proxy当具体handler被调用时，会去实例化对应的handler，然后调用，这里面依赖的app完全是要兼容之前的代码而已。在这里handler一般是不复用的，当然也可以复用，这里主要复用的是service, util, consts等模块，复杂的例子可以看
2：bearcat 对象共享可以看
其实就是一个匿名对象，通过 require(&bearcat&) 的都是同一份 3：car 确实需要知道依赖的engine的run方法，但是解偶的一个是engine的文件位置，叫什么名字（engine甚至可以是一个remote对象），还有就是engine的实例生成，无需自己再new来进行实例化，这样子其实就是面向接口编程了，你只需要知道依赖的对象里面提供了什么接口即可，至于到底文件在什么位置，叫什么名字（require这两点是必须要知道的），什么时候实例化（有些时候需要单例，有些时候需要多例）都不用关心 这样做的一个比较显著的好处就是便于单元测试，可以方便的mock对象，并且无缝的切换
var userService = require(&../service/user-service&);
exports.allUsers = function (req, res, next) {
userService.getUsers(function (err, users) {
if (err) {
return next(err);
res.json(users);
你这里要对controller进行单元测试，需要userService的一个mock对象，这里你是直接require的，这时你必须要么修改userService的代码，要么就是修改userController的代码，比如这样：
//var userService = require(&../service/user-service&);
var userService = require(&../service/mock-user-service&);
exports.allUsers = function (req, res, next) {
userService.getUsers(function (err, users) {
if (err) {
return next(err);
res.json(users);
通过ioc的话，你只需要修改下配置，把userService依赖注入的对象换成userController即可，非常便捷
@ 通过ioc的话，你只需要修改下配置，把userController依赖注入的对象换成mock-user-service即可，非常便捷 最后一句有笔误
@ 恩。你讲了以后更懂一些了。bearcat解耦的是对象生成依赖这个步奏，并不是解耦对象间的接口依赖关系。后续能否添加后者呢？类似于C/C++的h文件来定义接口。好像微软的typescript就是这个思路来做得。
@ 1：这个标准的js，没有interface这种概念把，目前只要合理安排类之间的关系，写在prototype里面的方法也是比较容易找到的 2：如果是rpc接口的话，一般是会有文档对应的把
NB啊，支持无缝融合到POMELO主版本
有看了一会儿bearcat，感觉文档还是没把几个关键概念技术讲清楚，搞得大家都看不懂。我才开了个开头就晕了，先问两个个问题吧，后面看到问题再问。
1，func : bean 的构造函数我测试发现这个名字必须和bean的文件名一模一样，大小写也一样才行，也就是说这个func其实就替代require(&xxx&)对吧？同时module.exports导出的必须是函数对吧？我开始看半天不知道这个构造函数是哪里来的。
2，func和factoryBean，factoryMethod 是什么关系？既然func和factoryBean都可以生成bean对象，那区别是什么？
刚刚又测试了，如果源文件改目录了，func字段也得改。
&func&: &./folder/helloBearcat&
说白了func配置就等于原来nodejs的require对吧。既然这样，这个字段就叫require不是很容易理解么？搞个func出来，文档就4个字“构造函数”（我一开始按照文档上说的在例子上去找这个构造函数，看了半天也没法发现有个helloBearcat函数，最后猜测是不是这个东西就是文件名才发现居然这货其实就是require，这种标准的词不达意是故意来挖坑么？），然后大家一看都看不懂，严重降低了大家继续看这个库的积极性。
@恩，针对roytan的疑问，这里简单回答一下哈 1：func 指向的确实是构造函数，在context.json里面配置的是 一个 字符串，因此就需要对应到具体的文件 除了在context.json里面定义之外，还可以直接写在 js 文件里面定义的，这时候的 func 就是一个 构造函数，这点可以参考
2：factoryBean factoryMethod 对应的是工厂模式，比如之前有一个非bearcat管理的js对象，那么你可以通过一个工厂方法来进行管理
感谢roytan耐心提出文档不足之处，我们会马上跟进修改的，也希望多一点耐心，bearcat 确实是一个值得使用研究的框架，用到的思想都是经过企业级服务验证的（主要可以参考java 的 spring）
@ 基于代码的元数据配置func确实是构造函数，但怎么感觉是侵入方式的呢？car.js被侵入了bearcat的导出配置。
var Car = function() {}
Car.prototype.run = function() {
console.log(&run car...&);
return &car&;
// func is the constructor function
module.exports = {
id: &car&,
另外这句话，文档也误导了我：
而配置文件形式的元数据配置的 func 配置则是一个 String 用于指明构造函数的位置.
基于配置文件的形式，明显这个func指代的文件路径而不是构造函数。
1：侵入也是没办法的，但是写在js代码里面，可以比较方便进行修改，不用老是对context.json修改，这个就需要权衡了 这里好的使用方式就是业务层代码可以吧配置写在js里面，而如果是库，需要给第三方用的话，还是配置在context.json里面为好，这样就不需要直接依赖于bearcat 分别对应于
2：func 的说明还有点改进哈
恩。我也觉得用context.json的方式要好一些。
现在的例子主要都是讲怎么使用bean。等弄个demo举例一下bearcat面向切面编程的用法么？感觉这个东西如果用好了的话，可以把逻辑代码修改得很清晰。
@恩，可以滴，目前的话，有两个地方可以看看 1： 2：
空时把 aop 的例子再完善完善，多谢指出不足之处
@具体的库实践可以参考 1： 2：
@ 我看到你的bearcat的examples里面里面有个aop目录，里面有些代码，但是怎么跑起来看看呢？
@ 把aop跑起来和跑普通的bearcat是一样的，只需要吧context.json传入bearcat即可 然后可以得到bean，去执行
var Bearcat = require(&bearcat&);
var contextPath = require.resolve(&./context.json&);
var bearcat = Bearcat.createApp([contextPath]);
bearcat.start(function(){
var car = bearcat.getBean(&car&); // get bean
car.runBefore(); // call the method
为什么car需要调用car.runBefore();呢？感觉有点不智能呢？感觉相当于显示给car加了新函数。
我看meld库是这样做的，似乎更加友好：
var myObject = {
doSomething: function(a, b) {
return a +
// Call a function after myObject.doSomething returns
var remover = meld.after(myObject, &doSomething&, function(result) {
console.log(&myObject.doSomething returned: & + result);
myObject.doSomething(1, 2); // Logs: &myObject.doSomething returned: 3&
remover.remove();
myObject.doSomething(1, 2); // Nothing logged
car.runBefore()
就是普通方法啊，只是叫runBefore而已
bearcat aop 的 pointcut 采用的是正则表达式进行匹配的，具体怎么匹配全看你怎么定义的 例子中的pointcut定义是
&pointcut&: &before:.*?runBefore&
所以凡是容器中匹配到 runBefore 的对象中的方法都会被切入拦截 这个是无侵入式的，全靠容器来自动匹配完成
meld 这个库之前也没有了解过，大致看了下 它这个就有点 侵入式 的了，依赖于 meld 的 api 除去 meld 依赖之后就有问题了，需要把 meld 相关都给去掉 但是bearcat就不会，比如
代码完全可以在有 bearcat-jstrace 的情况下跑和没有的情况下跑 而且切入的逻辑是可配置的，即可以指定具体需要拦截哪些方法 比如，可以拦截所有的Service方法，或者所有的Dao方法，全在你的pointcut定义儿
这个例子不知道是不是bearcat的aop的意思，我感觉这种思路是非侵入式的扩展了原有方法的功能。
@1：bearcat aop 是通过动态代理实现的，凡是被pointcut匹配到的POJO，从bearcat.getBean拿到的就是一个proxy对象 2：然后在这个代理对象里面注入各种横切逻辑 给出的连接确实有点AOP的意思了，不过bearcat通过编写aspect，描述pointcut和advice来把横切逻辑的描述和切入都进行了抽象，可以方便的像使用普通对象一样使用（但其实已经被切入了横切逻辑）
这两天好好看了一下，觉得配置对象容器和aop这两个功能正好对pomelo能起到很好的补充作用，进一步让代码清晰有条理。
但是项目原来的代码已经很多了，想要改成使用bearcat的，改动量太大了，有点纠结。不过bearcat确实是好东西。
@恩，多谢支持哈，确实老的项目重构过来代价还是挺大的，我们这边老的项目也在慢慢的改，风险还是有的
库里面的aop的例子跑起来有错呢？
[ 22:10:20.263] [INFO] bearcat - [app] Bearcat startup in dev with 11 ms
Aspect doBefore
Aspect doBeforeOrder
runBefore car...
/home/roytest/demo/car.js:12
cb(null, &car&);
TypeError: undefined is not a function
at Car.runBefore (/home/roytest/demo/car.js:12:2)
at /home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:122:28
at next (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:154:11)
at _next (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:162:4)
at Aspect.doBeforeOrder (/home/roytest/demo/aspect.js:14:2)
at next (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:169:22)
at _next (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:162:4)
at Aspect.doBefore (/home/roytest/demo/aspect.js:9:2)
at next (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:169:22)
at DynamicAopProxy.doInvokeAdvisorsBefore (/home/roytest/demo/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:173:2)
哦，调用car.runBefore(); // call the method还得传一个function进去。
@这是个一个有cb的方法把，和你普通node写法一样啊，我例子里面没对 cb 做判断
car.runBefore(function(err, r) {
cb 要手动传入哦
这里在AOP情况下调用对象里面的方法和普通的node写法是一样的哈
&pointcut&: &before:.*?runBefore&,能讲讲这里的正则表达式么？匹配的是什么东西？
.*?匹配的是beans的id还是id+函数名？
@1：这个要看这里
2：AOP要匹配到POJO的目标方法，目前的POJO的目标方法都有这样子的形式来唯一表示
id 是目标bean的唯一id method 是目标对象的方法名
这个就相当于用正则表达式匹配一个字符串了
比如如果目标对象以id为car为名, 并且有一个方法名叫runBefore 那么的它的唯一表示就是
car.runBefore
之后你就写一个正则表达式来匹配这个表示就行了
.*?runBefore
这个正则是可以匹配的 例子中写的比较简单，你可以写一个范围更加精确的正则来限定AOP关系的
建议象百科和wiki上讲解aop那样写个简单的example。
AOP是OOP的延续。
主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
写这样一个example，简单又明了的阐述了AOP功能。
@恩感谢指出，会马上改进的哈
context.json只能有一个吗？context.json如何引入另一个context.json？比如我想划分成多个模块，每个模块一个context.json，然后各个模块又可以一起工作。一个context.json的话，在项目复杂以后，该文件会变得太大了。
@哦这个是文档里面漏了，bearcat 支持引入其它的 context.json 的
&imports&: [&app/beans.json&]
例子在这里
文档马上更新哈
@ 就是这样才对哈，不然搞死人啊
@ 不同的context有不同的name。使用子context的bean对象方法是不是应该这样用？
contextName.beanName.beanMethod
@ 1：这个没这样用啊，直接就把不同的 context.json 的 imports 进去就行了 2：bean 主要还是以 id 为区分的
1，那context1和context2有两个id都叫car的bean，外面怎么区分呢？
2，也就是说bean的id必须是全局唯一？这样有点不合适吧？
@ 恩, id 是要求全局唯一的，这样有什么不合适吗？一个系统中肯定不会出现两个同名的car的把
@ id全局唯一，那这样context就感觉意义不大了。我一直以为context就类似于C++和java的命名空间的感觉。一个大项目必然是很多人协同开发的，那么类名（bean名）就很可能在不同开发人员那里不经意出现重复。
@ 1：还是id唯一比较好把，比如你要用某个service，你根据id直接就能定位到了，如果还有context一层的话，你就需要找好几次了 2：项目协作的话，一般也不会把id写成同一个的把，换个名字就可以解决了，但是你的function名，文件名都可以相同的
总的来说1：id 唯一 bearcat 实现起来比较简单，不容易出现bug （否则首先你要维护所有的context层，然后getBean的时候，如果直接id找不到的情况，你还要根据context来进一步查找）2：对开发者来说，至少可以满足80%以上的开发需求，以较少的代价满足绝大多数需求这也是考虑之一
既然设计这个bearcat就是用来解耦大项目中复杂的依赖关系，我觉得那思路上就不该用这种简单的全局bean id。举例来讲java和C++里面如果没有命名空间，包名的话，肯定是没法做大项目的。真不敢想象java如果没有包名的话那得乱成什么样子。因为如果仅仅是做小项目的话，根本没有必要用bearcat。这是一个矛盾的问题，你想想？
再举个最常见的例子，我看到无数的开发者都在自己的模块里面有一个util类，同样的类名实现了各种各样七七八八的小功能。那么很可能不同人的n个模块就有n个util类。如果象现在bean id这样要全局唯一，那这些util类的bean名字该怎么命名呢？
@ 恩，确实需要，感谢指出，在context.json里面加一个namespace以做区分
@ 最新版的bearcat已经支持namespace了哈 getBean或者依赖注入的时候，如果是在namespace里面的，就必须要加上namespace，即需要这样子的
namespace:id
非常感谢添加这个功能
@ 哈哈，全靠你指出来啊，以后还望多多交流
@ 有了这个namespace以后，aop在正则表达式的时候是否也需要带namespace呢？
另外有一个建议，在Bean 属性的配置里面加一个interfaces字段，描述该对象对外的方法和调用参数。这样不管是aop切入或者普通使用bean对象都更加直观了，不用每次使用一个bean都得去看其源代码。context.json也更具有配置的意义。
@interfaces 放在 bearcat 里面貌似没多大意义啊，开发者如果有这样的需求的话，可以直接在beans的定义里面添加的哦
如何把pomelo的app对象暴露成bearcat的一个单例bean呢？这样原来项目中的很多地方就不用带着app走了，要用的时候从bearcat里面拿就行了。
@这个还不简单啊
var pomeloBean = function() {
pomeloBean.prototype.getApp = function() {
return require(&pomelo&).
var self =
* Create an pomelo application.
* @return {Application}
* @memberOf Pomelo
* @api public
Pomelo.createApp = function (opts) {
app.init(opts);
self.app =
* Get application
Object.defineProperty(Pomelo, &app&, {
get:function () {
return self.
我没有看明白pomelo.js的这句话什么意思：
var self =
这个this是谁呢？
@ 文件内的this就是{}把 不信可以试试 test.js
console.log(this);
相当于你在闭包外面声明了一个全局对象，然后保存下app对象而已
@ 试验结果确实var self = 等于var self = {};搞不懂为什么不直接写：
var self = {};
这样不是清晰很多么。
@ 哈哈，这个欢迎pull request
建议有兴趣的可以看看livescript，和bearcat一起用起来，在实现面向对象和对象管理上面很好用。不建议用coffeescript，它的变量scope是个很诡异的东西。
@ 有了这个namespace以后，aop在正则表达式的时候是否也需要带namespace呢？
@要的要的，当然可以匹配的弱些，即namespace不管 看你正则怎么写了
报一个bug：
&beans&: [{
&id&: &mdb&,
&func&: &mongodbc&,
&factoryBean&: &mongodbc&,
&factoryMethod&: &getDBconnection&,
我发现这里必须要func，不然bearcat启动报错。但是这里已经指定了factoryBean和factoryMethod，已经可以通过工厂模式生成id为mdb的bean了，这里为什么还必须要配置func呢？
另外，我觉得在使用bearcat的时候factory模式比func模式好，因为func模式必须导出的是一个自定义function作为bean，而factory模式可以到处任意的东西作为一个bean，这样更加便于和已有的代码结合。
@ 恩，这里确实有这个问题，感谢指出
恩，上面那个不是bug，是我没有用对。原来用factoryBean得2级嵌套才行，不是直接定义就可以用了，又被文档坑了。最后看examples才搞懂怎么用。
而且factoryArgs无效，args得写到2级bean里面才行。。。
这样就可以工作了。为了使用bearcat的getBean直接拿到一个mongoose对象，饶了这么大一圈。。。而且这配置还看起来这么古怪。
&name&: &test_data_context&,
&beans&: [
&id&: &mongodbc&,
&func&: &mongodbc&,
&factoryBean&: &mongodbcFactory&,
&factoryMethod&: &getDBconnection&,
&scope&: &singleton&
&id&: &mongodbcFactory&,
&func&: &mongodbc&,
&scope&: &singleton&,
&args&: [{
&name&: &opts&,
&value&: {
&dbUser&: &test&,
&dbPassword&: &123456&,
&dbHost&: &127.0.0.1&,
&dbPort&: 27017,
&dbName&: &testdb&
mongodbc的代码
mongoose = require &mongoose&
dbc = mongoose.connection
dbc.on &error&, (err) -&
console.log &mongoose db error = &, err
dbc.on &open&, -&
console.log &mongoose db open ok !&
createDBconnection = (opts) -&
console.log &createDBconnection called opts = &, opts
dbUri = &mongodb://& +
opts.dbUser + &:& +
opts.dbPassword + &@& +
opts.dbHost + &:& +
opts.dbPort + &/& +
opts.dbName
dbOptions =
poolSize: 30
socketOptions:{ keepAlive: 1 }
socketOptions:{ keepAlive: 1 }
mongoose.connect(dbUri, dbOptions);
return mongoose
getDBconnection = -&
console.log &mongodbc getDBconnection called &
return mongoose
DBFactory = (opts) !-&
console.log &DBFactory called opts = &, opts
dbOpts = opts || {
dbUser: &test&
dbPassword: &123456&
dbHost: &127.0.0.1&
dbPort: 27017
dbName: &test&
createDBconnection(dbOpts)
DBFactory.prototype.getDBconnection = getDBconnection
module.exports = DBFactory
bearcat的func只能导出函数，不能导出对象，用起来很不方便。总是报错：
[ 14:17:28.502] [ERROR] bearcat - [BeanFactory] registryBean &userModel& metaObject {&id&:&userModel&,&func&:&userModel&,&scope&:&singleton&} validate error
为了导出对象还得配置factory加个bean去转一次，太麻烦了。
$注入不会和其他库冲突吗？比如mongodb里面很多这样的写法，很想知道bearcat的$注入的判断条件是什么？有没有什么配置可以关闭bearcat的$注入的？
collection.insert(doc, {w:1}, function(err, result) {
collection.update({mykey:1}, {$set:{fieldtoupdate:2}}, {w:1}, function(err, result) {});
var doc2 = {mykey:2, docs:[{doc1:1}]};
collection.insert(doc2, {w:1}, function(err, result) {
collection.update({mykey:2}, {$push:{docs:{doc2:1}}}, {w:1}, function(err, result) {});
@ $ 只在构造函数或者aop的prototype的function里面有效
this.$id =
var $pointcut = &&;
这种基本没影响把，mongo这个是参数里面的对象属性了，更不会影响到了
var Car = function() {
this.$id = &car&;
module.exports = C
var Aspect = function() {
this.$id = &aspect&;
this.$aop =
module.exports = A
Aspect.prototype.doBefore = function(next) {
var $pointcut = &before:.*?runBefore&;
var $order = 10;
console.log(&Aspect doBefore&);
$ 只在构造函数或者aop的prototype的function里面有效 ？？？好像不是这样的吧，你的例子代码是这样的，run里面这种普通函数也用了。
var Car = function($engine) {
this.$id = &car&;
this.$scope = &prototype&;
this.$engine = $
this.$wheel =
this.$Vnum = &${car.num}&;
Car.prototype.run = function() {
this.$engine.run();
var res = this.$wheel.run();
console.log(&run car...&);
return &car & +
这是mongodb的一种用法：
Model.$where(&this.firstname === this.lastname&).exec(callback)
那正好this就是Model呢？
this.$where(&this.firstname === this.lastname&).exec(callback)
这种时候会冲突吗？
@ this.$engine ?
这种就是自定义的变量名啊 不是bearcat关键字了，不像 this.$scope 这种，这种是bearcat关键字，只在构造函数里面有 this.$engine 就是一个自定义的变量了，开发者不要写成冲突的就成了 就像变量名不会取成 in 这种 js 的关键字吧
this.$engine = $
this.$wheel =
ok，按照你的说法“this.$engine ? 这种就是自定义的变量名啊 ”this.$engine是自定义变量名，$engine是传入的注入参数这个可以理解。那么同理this.$wheel =这个this.$wheel也应该是自定义变量名吧？
那么为什么在run的时候var res = this.$wheel.run();这样居然可以跑呢？this.$wheel这种自定义变量名为什么又自动被bearcat注入了？那么我用this.$where不是也就被bearcat注入了？
我觉得真应该加一个开关来控制$注入功能，$被太多的第三方库借用了，冲突是肯定会有的。$注入式很好的功能，但是作为bearcat本身应该提供是否使用该功能的选择权给用户。
@ 第三方库不用被bearcat扫描吧，bearcat管理的是开发者的beans，第三方库封装在bean里面使用是比较好的实践 当然bearcat提供一个开关配置来是否启用 $ 注解也是可以的
@ 开发组的bean里面用了第三方库，然后第三库也把用户bean代码里面的$特殊处理了。这就和bearcat冲突了。加配置开关是必要的。
先解决导出对象的问题吧，现在这样绕一大圈才能导出对象的方案太麻烦了。
@导出对象？ 这个bean的实例化都是交给bearcat管理的，如果不是bean的对象，生成对象还是挺容易的吧
导出对象的问题。现在用func看文档和例子都是只能导出function：
var Car = function() {
module.exports = C
这种自定义的Car这样通过func导出当然没有问题。但是如果我想导出一个mongodb的Model或者db连接这种第三方的对象出来呢？于是只能用factoryBean通过其factoryMethod返回一个Model对象才可以。
比如我要导出一个已经链接成功可以全局使用的mongoose对象供其它地方使用，目前我能想到bearcat的方法就是
getDBconnection = -&
console.log &mongodbc getDBconnection called &
return mongoose
DBFactory = (opts) !-&
console.log &DBFactory called opts = &, opts
createDBconnection(dbOpts)
DBFactory.prototype.getDBconnection = getDBconnection
module.exports = DBFactory
通过在context.json里面指定mdb的factoryBean是DBFactory，factoryMethod是getDBconnection，这样其它地方getBean(&mdb&)返回的才是直接可用的mongoose对象。
@ 这个确实要这样啊，不过其实可以不需要mdb这个bean的 DBFactory 也可以不用factory模式，直接实现一个单例的bean，即可 可以参考下
。。。怎么就说不明白呢。。。我要导出的是对象 Object 不是 function ！！！你给的例子仍然还是导出的是function！
var MysqlConnectionManager = function() {
util.inherits(MysqlConnectionManager, EventEmitter);
module.exports = MysqlConnectionM
我需要getBean(&xxx&)拿到的是一个ObjectJavaScript 里面function和Object不是同一个东西吧？是我表达有问题？
@ 也就是说如果module.exports = function()，那么这个bean的生成对象是被bearcat管理的，bearcat会new bean出来给外面用。如果module.exports = Object，那么表明该bean对象已经有了，bearcat直接拿来交给外面用就行了，不用再去new了
但是目前bearcat只支持第一种模式对吧？要实现导出已有对象只能用factoryMethod才行。
@ 可能是我没有表达清楚，准确的说应该是用bearcat导出已有对象
@ 这里function就相当于class，getBean拿到的是object啊 定义的是class，使用的是object吧 上面你的例子获取mongo连接你是这样子的吧，这样子拿到一个第三方的对象
var mongoConnection = bearcat.getBean(&mongodbc&);
这样子就需要搞一个factory了
其实可以实现一个connectionManager这样的单例bean
var connectionManager = bearcat.getBean(&connectionManager&);
var mongoConnection = connectionManager.getMongoConnection();
通过一个函数来得到也行哈
@ 恩，不纠结于这个了。多次使用以后，我现在是完全搞明白怎么用bearcat导出class和导出第三方object了。
如果是自定义对象，就用普通func定义class；如果是第三方对象，就用factory或者加一个get函数。
@ 先加$注解配置开关吧，这个功能很重要，我还是倾向于用context.json的非侵入方式使用bearcat库。所以很需要这个开关来避免潜在的和第三方库冲突的问题。
@各位亲为毛aop 拦截invoke方法报错？代码如下：car.js添加如下方法：
Car.prototype.invoke = function(cb) {
console.log(&runInvoke car...&);
cb(null, &car&);
context.json配置
&id&: &aspect&,
&func&: &aspect&,
&pointcut&: &before:.*?invoke&,
&advice&: &doBefore&,
&order&: 10
/usr/local/bin/node app.js
[ 10:25:28.255] [INFO] bearcat - [app] Bearcat startup in dev with 16 ms
/usr/local/dev/access_/core_zero_nodejs/zero/src/node_modules/bearcat/lib/aop/framework/dynamicAopProxy.js:48
arguments = Array.prototype.slice.apply(arguments);
RangeError: Maximum call stack size exceeded
把DynamicAopProxy.prototype.invoke 方法的invoke改成其他（如：invokeXXX）就好使 了。除了修改invoke还有什么办法能解决这个问题或者是我缺少什么配置参数？
谢谢！！！！！
@ 这个问题已经修复鸟，更新最新的bearcat即可解决哈
@ 太好了，辛苦了。
@，你好：我在用aop过程中出现了一个小问题；我的aspect.js方法如下：
Aspect.prototype.doBeforeRuntime = function(num, cb, next) {
console.log(&Aspect doBeforeRuntime & + num);
next && next();
我的app.js是这样调用的：
bearcat.start(function() {
var car = bearcat.getBean(&car&); // get bean
car.runTimeBefore(10,null/*,function(error,msg){
console.error(error);
console.error(msg);
}*/); // call the method
第二个参数传值null，不传callback函数，然后doBeforeRuntime 方法的next参数就变成undefined，next && next();这段代码不能被执行，下面的工作无法进行。如果我传callback的话正常工作，但是在业务当中不需要callback。我该怎么办？？？ 谢谢解答！！！！！
我测试的是
&pointcut&: &before:.*?runTimeBefore&,
&advice&: &doBeforeRuntime&,
&runtime&: true
如果我的第二个参数有值的情况下，能正常运行。
@wangbinIml 我自己试了可以的哈 car.js
Car.prototype.runTimeBefore = function(num, cb, next) {
// cb(null, &car& + num);
console.log(cb);
Aspect.prototype.doBeforeRuntime = function(num, cb, next) {
console.log(&Aspect doBeforeRuntime & + num);
var car = bearcat.getBean(&car&);
var cb = function(err, r) {
console.log(r);
var r = car.runTimeBefore(100, null, function() {
console.log(&next called&);
@ 必须要传callback函数吗。
@ 你目标函数怎么写就怎么调啊
car.run();
有没有aop run 方法调用都是一样的，里面三个参数的话，那就是三个参数
if (!Utils.checkFunction(invokeCb)) {
// aop target args last must be next function
//if (invokeCb) {
args.push(invokeCb);
invokeCb = function() {};
如果第二个参数是null的话args里面就pop了。
@ 所以我把
//if (invokeCb) {
注掉了，不管你传什么参数过来都保留在args里面，这样就没问题了
@ 这个取的是最后一个参数啊
@ 对，只是我的业务里面不需要传回调，所以才出现这个问题；比如我的业务这样用：car.runTimeBefore(10,null);
@ 你的 runTimeBefore 咋定义的就是怎么调用的
@ 恩恩，但是如果我的最后一个参数是null时候（比如这样：
car.runTimeBefore(10,null);
），下面的代码会pop掉最后那个参数null。
var self =
var invokeCb = args.pop();
var flag =
if (!Utils.checkFunction(invokeCb)) {
**// aop target args last must be next function**
//if (invokeCb) {
args.push(invokeCb);
invokeCb = function() {};
@ 这个貌似是这样的，如果是一个同步方法，那么最后一个参数为null确实会有问题，貌似传入0也会有问题 已更新，你试试最新的看看 如果还有问题，及时联系，感谢指出哈
to @请问哪有类继承的IOC例子？
var ic = require(&./IntegrationClient&);
var util = require(&util&);
function ClientImpl(){
//调用父类的构造函数
ic.call(this,&service&);
util.inherits(ClientImpl, ic);
module.exports = ClientI
这种继承在bearcat 怎么实现注入?
@wangbinIml 看这里吧