Menu
▾
▴
springframework-developer
|
From: <jue...@we...> - 2003-08-25 22:04:18
|
Q29saW4sDQogDQpZb3Ugb2J2aW91c2x5IHdhbnQgdG8gcGVyZm9ybSBwbGFpbiBKREJDIGFjY2Vz cyB3aXRoaW4gdGhlIHNhbWUgdHJhbnNhY3Rpb24gYXMgdGhlIEhpYmVybmF0ZSBhY2Nlc3MuIFRo aXMgY2FuIGJlIGFjaGlldmVkIGVhc2lseSB2aWEgSGliZXJuYXRlVHJhbnNhY3Rpb25NYW5hZ2Vy IG9yIEp0YVRyYW5zYWN0aW9uTWFuYWdlciwgd2l0aG91dCBhbnkgc3BlY2lmaWMgZ2x1aW5nLg0K IA0KSWYgeW91IGRlZmluZSBhIHJlc3BlY3RpdmUgSkRCQyBEYXRhU291cmNlIGluIHRoZSBhcHBs aWNhdGlvbiBjb250ZXh0LCBwb2ludGluZyB0byB0aGUgc2FtZSBvbmUgdGhhdCBIaWJlcm5hdGUg dXNlcyAoYmUgaXQgYSBsb2NhbCBvbmUgc3BlY2lmaWVkIG9uIExvY2FsU2Vzc2lvbkZhY3RvcnlC ZWFuIG9yIGEgc2hhcmVkIEpOREkgb25lKSwgeW91IGNhbiBtYWtlIEhpYmVybmF0ZVRyYW5zYWN0 aW9uTWFuYWdlciBleHBvcnQgaXRzIHRyYW5zYWN0aW9ucyBmb3IgdGhpcyBwYXJ0aWN1bGFyIERh dGFTb3VyY2UgYnkgcGFzc2luZyB0aGUgRGF0YVNvdXJjZSBhcyBiZWFuIHJlZmVyZW5jZSBpbnRv IGl0cyAiZGF0YVNvdXJjZSIgcHJvcGVydHkuIEhpYmVybmF0ZVRyYW5zYWN0aW9uTWFuYWdlciB3 aWxsIHNpbXBseSB0YWtlIHRoZSB2ZXJ5IEpEQkMgQ29ubmVjdGlvbiB0aGF0IHRoZSBIaWJlcm5h dGUgU2Vzc2lvbiB1c2VzIGFuZCBiaW5kIGl0IHRvIHRoZSB0aHJlYWQgdmlhIERhdGFTb3VyY2VV dGlscyBmb3IgcGxhaW4gSkRCQyBhY2Nlc3Mgb24gdGhhdCBEYXRhU291cmNlLiBUaGUgbGF0dGVy IGRvZXMgbm90IGhhdmUgdG8gYmUgYXdhcmUgdGhhdCBpdCBpcyB3b3JraW5nIHdpdGggYSBIaWJl cm5hdGUtcHJvdmlkZWQgQ29ubmVjdGlvbiENCiANCldpdGggSnRhVHJhbnNhY3Rpb25NYW5hZ2Vy LCBpdCdzIHNpbWlsYXI6IERlZmluZSB0aGUgc2FtZSBKTkRJIERhdGFTb3VyY2UgdGhhdCB0aGUg SGliZXJuYXRlIFNlc3Npb25GYWN0b3J5IHVzZXMgZm9yIHRoZSBKZGJjVGVtcGxhdGUsIGFuZCBK VEEgd2lsbCBjYXJlIGZvciByZXR1cm5pbmcgdGhlIHNhbWUgQ29ubmVjdGlvbiB0byBib3RoIHRo ZSBIaWJlcm5hdGUgU2Vzc2lvbiBhbmQgdGhlIEpEQkMgYWNjZXNzIGNvZGUgaWYgaW4gYW4gYWN0 aXZlIHRyYW5zYWN0aW9uLg0KIA0KU28gaW4gYW55IGNhc2UsIHRoaXMgInNhbWUgRGF0YVNvdXJj ZSIgYXBwcm9hY2ggaXMgYXMgZWZmaWNpZW50IGFzIHBhc3NpbmcgdGhlIEhpYmVybmF0ZSBTZXNz aW9uJ3MgSkRCQyBDb25uZWN0aW9uIG1hbnVhbGx5IHRvIGEgSmRiY1RlbXBsYXRlIGluc3RhbmNl LCBhcyBpdCByZXVzZXMgdGhlIHNhbWUgQ29ubmVjdGlvbiBmb3IgYm90aCB0aGUgSGliZXJuYXRl IFNlc3Npb24gYW5kIHRoZSBKZGJjVGVtcGxhdGUgd2l0aGluIGEgdHJhbnNhY3Rpb24uIEkgc3Ry b25nbHkgcmVjb21tZW5kIHN1Y2ggYSBzb2x1dGlvbiBvdmVyIG1hbnVhbCBnbHVpbmcuDQogDQpK dWVyZ2VuDQogDQogDQoNCgktLS0tLVVyc3Byw7xuZ2xpY2hlIE5hY2hyaWNodC0tLS0tIA0KCVZv bjogQ29saW4gU2FtcGFsZWFudSBbbWFpbHRvOmNvbGlubWwxQGV4aXMuY29tXSANCglHZXNlbmRl dDogTW8gMjUuMDguMjAwMyAyMzoxNCANCglBbjogasO8cmdlbiBow7ZsbGVyIFt3ZXJrM0FUXSAN CglDYzogc3ByaW5nZnJhbWV3b3JrLWRldmVsb3BlckBsaXN0cy5zb3VyY2Vmb3JnZS5uZXQgDQoJ QmV0cmVmZjogUmU6IFtTcHJpbmdmcmFtZXdvcmstZGV2ZWxvcGVyXSBXaHkgZG9lcyBTaW5nbGVD b25uZWN0aW9uRGF0YVNvdXJjZSBhbHdheXMgc2V0IGF1dG9Db21taXQ9dHJ1ZT8NCgkNCgkNCg0K CVcvcmVnYXJkcyB0byBhdXRvIGNvbW1pdCBpbiB0aGUgZGVmYXVsdCBjYXNlICh3aGVuIHRoZSBj bGFzcyBnZXRzIHRoZQ0KCWNvbm5lY3Rpb24gaXRzZWxmKSwgSSB3b3VsZCBzYXksIGV4YWN0bHks IHRoZSBKREJDIHNwZWNzIHNwZWNpZmljYWxseQ0KCXNheSB0aGUgZ2V0Q29ubmVjdGlvbiBjYWxs ZWQgb24gdGhlIGRhdGFzb3VyY2Ugd2lsbCByZXR1cm4gYSBjb25uZWN0aW9uDQoJd2l0aCBhdXRv Q29tbWl0IG9uIGJ5IGRlZmF1bHQuIFNvIHdoeSBpcyBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJj ZSB0aGVuDQoJZ29pbmcgYW5kIHNldHRpbmcgaXQgb24gYXMgd2VsbC4gR2l2ZW4gdGhhdCBTaW5n bGVDb25uZWN0aW9uRGF0YXNvdXJjZQ0KCWRvZXNuJ3QgaGF2ZSBhbnkgY2x1ZSBhYm91dCB0aGUg aW50ZW5kZWQgdXNlIG9mIHRoZSBjb25uZWN0aW9uLCB0aGUgbW9zdA0KCWNvcnJlY3QgYmVoYXZp b3VyIGlzIHByb2JhYmx5IHRvIG5vdCBoYXZlIGl0IGNhbGwgc2V0QXV0b0NvbW1pdCB3aXRoDQoJ ZWl0aGVyIHN0YXRlLCBieSBkZWZhdWx0LCB3aGljaCB3b3VsZCBtaXJyb3Igbm9ybWFsDQoJZGF0 YXNvdXJjZS9jb25uZWN0aW9uIHVzYWdlLCBhbmQgYWxzbyBhbGxvdyBhIG1lY2hhbmlzbSB0byBz cGVjaWZ5IHRoYXQNCglpdCBzaG91bGQgYmUgY2FsbGVkIG9uZSB3YXkgb3IgYW5vdGhlci4gSG93 ZXZlciwgdGhpcyBtYXkgYmUgbW9yZSB3b3JrDQoJdGhhbiBpcyB3b3J0aCBpdCwgYW5kIGEgZGVm YXVsdCBjYWxsIHdpdGggdGhlIG9wdGlvbiB0byBvbiwgYWxvbmcgd2l0aCBhDQoJbWVjaGFuaXNt IChhbm90aGVyIGNvbnN0cnVjdG9yIHdpdGggYSB2YWx1ZSBmb3IgdGhlIGNhbGwpIHRvIG92ZXJy aWRlDQoJaXQsIHdvdWxkIGJlIGZpbmUuIFNvIHRvIGJlIGNsZWFyLCBJIGRvIHRoaW5rIGV2ZW4g d2hlbg0KCVNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIGdldHMgdGhlIGNvbm5lY3Rpb24gdGhl cmUgaXMgYSBuZWVkIGZvciBhbg0KCW92ZXJyaWRlLg0KCQ0KCUFzIGZvciBteSB1c2UgY2FzZSwg SSBkb24ndCB0aGluayBJIHdhcyBjbGVhciBlbm91Z2guICBJIGhhdmUgc29tZSBjb2RlDQoJaW4g YSBIaWJlcm5hdGUgc3BlY2lmaWMgREFPL01hcHBlciBvYmplY3QuIEkgYW0gYWxyZWFkeSBleGVj dXRpbmcgaW5zaWRlDQoJYSB0cmFuc2FjdGlvbiBpbnRyb2R1Y2VkIHZpYSBTcHJpbmcncyBBT1Ag aW50ZXJjZXB0b3IuIFNvIEkgZG8gaGF2ZSBhDQoJU2Vzc2lvbkZhY3RvcnksIGV0Yy4gYm91bmQg dG8gdGhlIHRocmVhZC4gTm93IGluc2lkZSBhIG1ldGhvZCBpbiB0aGlzDQoJbWFwcGVyIEkgbmVl ZCB0byBkbyBhbiBvcGVyYXRpb24gb24gYSBCTE9CL0NMT0IsIHdoZXJlIHRoZXJlIGFyZSBhDQoJ bnVtYmVyIG9mIGRiIHBsYXRmb3JtIHNwZWNpZmljIGlzc3VlcywgYW5kIEhpYmVybmF0ZSdzIHN1 cHBvcnQgb2YNCglCTE9Ccy9DTE9CcyBpcyBub3QgZ29vZCBlbm91Z2guIEdpdmVuIHRoYXQgSSBo YXZlIGEgSGliZXJuYXRlIFNlc3Npb24NCgl3aGljaCBhbHJlYWR5IGhhcyBhIGNvbm5lY3Rpb24g YXZhaWxhYmxlLCB1c2luZyBpdCBpcyB0aGUgYmVzdCBtZWNoYW5pc20NCgkoYXMgb3Bwb3NlZCB0 byB0cnlpbmcgdG8gZ2V0IGEgcmVhbCBEYXRhU291cmNlIGluIFNwcmluZydzIGNvbnRleHQgdG8N Cgl1c2UpLiBOb3cgSSBhbSB1c2luZyBKREJDVGVtcGxhdGUgYW5kIEpEQkNIZWxwZXIgYXMgY29u dmVuaWVuY2UgY2xhc3NlcywNCgl0byB3cmFwIEpEQkMgZXhjZXB0aW9ucywgYW5kIGZvciB0aGUg bWV0aG9kcyB0aGV5IHByb3ZpZGUuIE5vdyBJIGNvdWxkIGNhbGwNCgkgIERhdGFTb3VyY2VVdGls cy5nZXRUaHJlYWRPYmplY3RNYW5hZ2VyKCkuYmluZFRocmVhZE9iamVjdCguLi4pDQoJdG8gYmlu ZCB0aGUgU2luZ2xlQ29ubmVjdGlvbkRhdGFzb3VyY2UgdG8gdGhlIHRocmVhZCwgYmVmb3JlIHVz aW5nIHRoZQ0KCUpEQkNUZW1wbGF0ZSwgYnV0IEknbSBub3Qgc3VyZSB0aGF0J3MgYnV5aW5nIG1l IG11Y2ggb3ZlciB0aGUgY2FzZSBvZg0KCW5vdCBiaW5kaW5nIGl0LiBJbiBlaXRoZXIgY2FzZSwg SkRCQ1RlbXBsYXRlIGlzIHNpbXBseSBnb2luZyB0byBlbmQgdXANCglnZXR0aW5nIHRoZSBzYW1l IENvbm5lY3Rpb24uIEJlY2F1c2UgSSBhbSB1c2luZyB0aGUNCglTaW5nbGVDb25uZWN0aW9uRGF0 YXNvdXJjZSwgaXQncyBub3QgbGlrZSBpbiB0aGlzIGNhc2UgdGhlcmUgaXMgYSByZWFsDQoJRGF0 YVNvdXJjZSBvYmplY3QsIGFuZCB5b3Ugb25seSB3YW50IHRvIGNhbGwgZ2V0Q29ubmVjdGlvbiBv biBpdCBvbmNlLi4uDQoJDQoJSG9wZWZ1bGx5IG15IGV4YXBsYW5hdGlvbiBpcyBjbGVhciBub3cu Li4NCgkNCgkNCglqw7xyZ2VuIGjDtmxsZXIgW3dlcmszQVRdIHdyb3RlOg0KCQ0KCT5JIGFncmVl IHRoYXQgaW4gY2FzZSBvZiBhbiBleGlzdGluZyBjb25uZWN0aW9uLCBTaW5nbGVDb25uZWN0aW9u RGF0YVNvdXJjZSBzaG91bGQgbm90IG92ZXJyaWRlIHRoZSBjb21taXQgbW9kZS4gRm9yIHRoZSBk ZWZhdWx0IGNhc2UsIEkgY29uc2lkZXIgYXV0byBjb21taXQgbW9kZSBhcHByb3ByaWF0ZSB0aG91 Z2guIEFueSBKMkVFIERhdGFTb3VyY2Ugd2lsbCByZXR1cm4gYW4gYXV0byBjb21taXQgY29ubmVj dGlvbiBvdXRzaWRlIGEgdHJhbnNhY3Rpb24sIHNvIHdoeSBzaG91bGRuJ3QgU2luZ2xlQ29ubmVj dGlvbkRhdGFTb3VyY2UgZG8gdG9vPw0KCT4NCgk+QlRXLCB3aGF0IHlvdSBhcmUgdHJ5aW5nIHRv IGRvIHNlZW1zIGEgYml0IGF3a3dhcmQuIFdoeSBtYW51YWxseSBmZWVkIHRoZSBDb25uZWN0aW9u IG9mIGEgSGliZXJuYXRlIFNlc3Npb24gdmlhIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIHRv IEpkYmNUZW1wbGF0ZT8gSmRiY1RlbXBsYXRlIGlzIHN1cHBvc2VkIHRvIGJlIGEgdGhyZWFkc2Fm ZSwgcmV1c2FibGUgb2JqZWN0LCBmZXRjaGluZyBjb25uZWN0aW9ucyBvbiBkZW1hbmQuIFdvdWxk bid0IGl0IGJlIGVhc2llciB0byB1c2UgU3ByaW5nJ3MgdGhyZWFkLWJpbmRpbmcgbWVjaGFuaXNt IChEYXRhU291cmNlVXRpbHMuZ2V0VGhyZWFkT2JqZWN0TWFuYWdlcikgdG8gbWFrZSBKZGJjVGVt cGxhdGUgdXNlIGEgc3BlY2lmaWMgY29ubmVjdGlvbiwgYmUgaXQgaW1wbGljaXRseSB2aWEgSGli ZXJuYXRlVHJhbnNhY3Rpb25NYW5hZ2VyIG9yIGV4cGxpY2l0bHkgaW4gc29tZSBjdXN0b20gd2F5 Pw0KCT4NCgk+SnVlcmdlbg0KCT4NCgk+DQoJPg0KCT4gICAgICAgLS0tLS1VcnNwcsO8bmdsaWNo ZSBOYWNocmljaHQtLS0tLQ0KCT4gICAgICAgVm9uOiBDb2xpbiBTYW1wYWxlYW51IFttYWlsdG86 Y29saW5tbDFAZXhpcy5jb21dDQoJPiAgICAgICBHZXNlbmRldDogTW8gMjUuMDguMjAwMyAyMDow Mg0KCT4gICAgICAgQW46IHNwcmluZ2ZyYW1ld29yay1kZXZlbG9wZXJAbGlzdHMuc291cmNlZm9y Z2UubmV0DQoJPiAgICAgICBDYzoNCgk+ICAgICAgIEJldHJlZmY6IFtTcHJpbmdmcmFtZXdvcmst ZGV2ZWxvcGVyXSBXaHkgZG9lcyBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJjZSBhbHdheXMgc2V0 IGF1dG9Db21taXQ9dHJ1ZT8NCgk+ICAgICAgDQoJPiAgICAgIA0KCT4NCgk+ICAgICAgIEkgd2Fu dCB0byB1c2UgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2Ugd2l0aCBIaWJlcm5hdGUsIHNvIEkg Y2FuIHdyYXAgYQ0KCT4gICAgICAgY29ubmVjdGlvbiBJIGdldCBmcm9tIGEgSGliZXJuYXRlIFNl c3Npb24sIGFuZCBmZWVkIGl0IGFzIGEgRGF0YVNvdXJjZQ0KCT4gICAgICAgdG8gSkRCQ1RlbXBs YXRlL0pEQkNIZWxwZXIuDQoJPiAgICAgIA0KCT4gICAgICAgSG93ZXZlciwgcmlnaHQgbm93IEkn dmUgaGFkIHRvIG1ha2UgbXkgb3duIHZhcmlhbnQgc2luY2UgdGhlIGN1cnJlbnQNCgk+ICAgICAg IGNvZGUgYWx3YXlzIGNhbGxzDQoJPiAgICAgICAgIHNvdXJjZS5zZXRBdXRvQ29tbWl0KHRydWUp Ow0KCT4gICAgICAgaW4gdGhlIGluaXQoKSBtZXRob2QuICBUaGlzIHNlZW1zIHZlcnkgYXJiaXRy YXJ5IHRvIG1lLiBBdCBsZWFzdCBpbiB0aGUNCgk+ICAgICAgIGNhc2Ugd2hlbiB0aGUgY2xhc3Mg aXMgZ2l2ZW4gYW4gZXhpc3RpbmcgY29ubmVjdGlvbiwgaXQgc2hvdWxkIGp1c3QNCgk+ICAgICAg IGFzc3VtZSB0aGUgY29tbWl0IG9wdGlvbiBoYXMgYmVlbiBzZXQgYXBwcm9wcmlhdGVseSBvbiB0 aGUgY29ubmVjdGlvbi4NCgk+ICAgICAgDQoJPiAgICAgICBFdmVuIGluIHRoZSBjYXNlIHdoZW4g dGhlIGNsYXNzIGlzIG9wZW5pbmcgdGhlIGNvbm5lY3Rpb24gaXRzZWxmIGZyb20gYW4NCgk+ICAg ICAgIGV4aXN0aW5nIERhdGFTb3VyY2UsIHRoZXJlIG5lZWRzIHRvIGJlIGFuIG9wdGlvbiB0byBz ZXQgYXV0b0NvbW1pdA0KCT4gICAgICAgZWl0aGVyIHdheS4NCgk+ICAgICAgDQoJPiAgICAgICBS ZWdhcmRzLA0KCT4gICAgICAgQ29saW4NCgk+ICAgICAgDQoJPg0KCQ0KCQ0KCQ0KDQo= |
|
From: <jue...@we...> - 2003-08-25 20:38:09
|
SSBhZ3JlZSB0aGF0IGluIGNhc2Ugb2YgYW4gZXhpc3RpbmcgY29ubmVjdGlvbiwgU2luZ2xlQ29u bmVjdGlvbkRhdGFTb3VyY2Ugc2hvdWxkIG5vdCBvdmVycmlkZSB0aGUgY29tbWl0IG1vZGUuIEZv ciB0aGUgZGVmYXVsdCBjYXNlLCBJIGNvbnNpZGVyIGF1dG8gY29tbWl0IG1vZGUgYXBwcm9wcmlh dGUgdGhvdWdoLiBBbnkgSjJFRSBEYXRhU291cmNlIHdpbGwgcmV0dXJuIGFuIGF1dG8gY29tbWl0 IGNvbm5lY3Rpb24gb3V0c2lkZSBhIHRyYW5zYWN0aW9uLCBzbyB3aHkgc2hvdWxkbid0IFNpbmds ZUNvbm5lY3Rpb25EYXRhU291cmNlIGRvIHRvbz8NCiANCkJUVywgd2hhdCB5b3UgYXJlIHRyeWlu ZyB0byBkbyBzZWVtcyBhIGJpdCBhd2t3YXJkLiBXaHkgbWFudWFsbHkgZmVlZCB0aGUgQ29ubmVj dGlvbiBvZiBhIEhpYmVybmF0ZSBTZXNzaW9uIHZpYSBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJj ZSB0byBKZGJjVGVtcGxhdGU/IEpkYmNUZW1wbGF0ZSBpcyBzdXBwb3NlZCB0byBiZSBhIHRocmVh ZHNhZmUsIHJldXNhYmxlIG9iamVjdCwgZmV0Y2hpbmcgY29ubmVjdGlvbnMgb24gZGVtYW5kLiBX b3VsZG4ndCBpdCBiZSBlYXNpZXIgdG8gdXNlIFNwcmluZydzIHRocmVhZC1iaW5kaW5nIG1lY2hh bmlzbSAoRGF0YVNvdXJjZVV0aWxzLmdldFRocmVhZE9iamVjdE1hbmFnZXIpIHRvIG1ha2UgSmRi Y1RlbXBsYXRlIHVzZSBhIHNwZWNpZmljIGNvbm5lY3Rpb24sIGJlIGl0IGltcGxpY2l0bHkgdmlh IEhpYmVybmF0ZVRyYW5zYWN0aW9uTWFuYWdlciBvciBleHBsaWNpdGx5IGluIHNvbWUgY3VzdG9t IHdheT8NCiANCkp1ZXJnZW4NCiANCiANCg0KCS0tLS0tVXJzcHLDvG5nbGljaGUgTmFjaHJpY2h0 LS0tLS0gDQoJVm9uOiBDb2xpbiBTYW1wYWxlYW51IFttYWlsdG86Y29saW5tbDFAZXhpcy5jb21d IA0KCUdlc2VuZGV0OiBNbyAyNS4wOC4yMDAzIDIwOjAyIA0KCUFuOiBzcHJpbmdmcmFtZXdvcmst ZGV2ZWxvcGVyQGxpc3RzLnNvdXJjZWZvcmdlLm5ldCANCglDYzogDQoJQmV0cmVmZjogW1Nwcmlu Z2ZyYW1ld29yay1kZXZlbG9wZXJdIFdoeSBkb2VzIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNl IGFsd2F5cyBzZXQgYXV0b0NvbW1pdD10cnVlPw0KCQ0KCQ0KDQoJSSB3YW50IHRvIHVzZSBTaW5n bGVDb25uZWN0aW9uRGF0YVNvdXJjZSB3aXRoIEhpYmVybmF0ZSwgc28gSSBjYW4gd3JhcCBhDQoJ Y29ubmVjdGlvbiBJIGdldCBmcm9tIGEgSGliZXJuYXRlIFNlc3Npb24sIGFuZCBmZWVkIGl0IGFz IGEgRGF0YVNvdXJjZQ0KCXRvIEpEQkNUZW1wbGF0ZS9KREJDSGVscGVyLg0KCQ0KCUhvd2V2ZXIs IHJpZ2h0IG5vdyBJJ3ZlIGhhZCB0byBtYWtlIG15IG93biB2YXJpYW50IHNpbmNlIHRoZSBjdXJy ZW50DQoJY29kZSBhbHdheXMgY2FsbHMNCgkgIHNvdXJjZS5zZXRBdXRvQ29tbWl0KHRydWUpOw0K CWluIHRoZSBpbml0KCkgbWV0aG9kLiAgVGhpcyBzZWVtcyB2ZXJ5IGFyYml0cmFyeSB0byBtZS4g QXQgbGVhc3QgaW4gdGhlDQoJY2FzZSB3aGVuIHRoZSBjbGFzcyBpcyBnaXZlbiBhbiBleGlzdGlu ZyBjb25uZWN0aW9uLCBpdCBzaG91bGQganVzdA0KCWFzc3VtZSB0aGUgY29tbWl0IG9wdGlvbiBo YXMgYmVlbiBzZXQgYXBwcm9wcmlhdGVseSBvbiB0aGUgY29ubmVjdGlvbi4NCgkNCglFdmVuIGlu IHRoZSBjYXNlIHdoZW4gdGhlIGNsYXNzIGlzIG9wZW5pbmcgdGhlIGNvbm5lY3Rpb24gaXRzZWxm IGZyb20gYW4NCglleGlzdGluZyBEYXRhU291cmNlLCB0aGVyZSBuZWVkcyB0byBiZSBhbiBvcHRp b24gdG8gc2V0IGF1dG9Db21taXQNCgllaXRoZXIgd2F5Lg0KCQ0KCVJlZ2FyZHMsDQoJQ29saW4N CgkNCgkNCgkNCgkNCgktLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tDQoJVGhpcyBTRi5uZXQgZW1haWwgaXMgc3BvbnNvcmVkIGJ5OiBWTSBXYXJl DQoJV2l0aCBWTXdhcmUgeW91IGNhbiBydW4gbXVsdGlwbGUgb3BlcmF0aW5nIHN5c3RlbXMgb24g YSBzaW5nbGUgbWFjaGluZS4NCglXSVRIT1VUIFJFQk9PVElORyEgTWl4IExpbnV4IC8gV2luZG93 cyAvIE5vdmVsbCB2aXJ0dWFsIG1hY2hpbmVzDQoJYXQgdGhlIHNhbWUgdGltZS4gRnJlZSB0cmlh bCBjbGljayBoZXJlOmh0dHA6Ly93d3cudm13YXJlLmNvbS93bC9vZmZlci8zNTgvMA0KCV9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQoJU3ByaW5nZnJhbWV3 b3JrLWRldmVsb3BlciBtYWlsaW5nIGxpc3QNCglTcHJpbmdmcmFtZXdvcmstZGV2ZWxvcGVyQGxp c3RzLnNvdXJjZWZvcmdlLm5ldA0KCWh0dHBzOi8vbGlzdHMuc291cmNlZm9yZ2UubmV0L2xpc3Rz L2xpc3RpbmZvL3NwcmluZ2ZyYW1ld29yay1kZXZlbG9wZXINCgkNCg0K |
|
From: Colin S. <col...@ex...> - 2003-08-25 21:14:28
|
W/regards to auto commit in the default case (when the class gets the connection itself), I would say, exactly, the JDBC specs specifically say the getConnection called on the datasource will return a connection with autoCommit on by default. So why is SingleConnectionDataSource then going and setting it on as well. Given that SingleConnectionDatasource doesn't have any clue about the intended use of the connection, the most correct behaviour is probably to not have it call setAutoCommit with either state, by default, which would mirror normal datasource/connection usage, and also allow a mechanism to specify that it should be called one way or another. However, this may be more work than is worth it, and a default call with the option to on, along with a mechanism (another constructor with a value for the call) to override it, would be fine. So to be clear, I do think even when SingleConnectionDataSource gets the connection there is a need for an override. As for my use case, I don't think I was clear enough. I have some code in a Hibernate specific DAO/Mapper object. I am already executing inside a transaction introduced via Spring's AOP interceptor. So I do have a SessionFactory, etc. bound to the thread. Now inside a method in this mapper I need to do an operation on a BLOB/CLOB, where there are a number of db platform specific issues, and Hibernate's support of BLOBs/CLOBs is not good enough. Given that I have a Hibernate Session which already has a connection available, using it is the best mechanism (as opposed to trying to get a real DataSource in Spring's context to use). Now I am using JDBCTemplate and JDBCHelper as convenience classes, to wrap JDBC exceptions, and for the methods they provide. Now I could call DataSourceUtils.getThreadObjectManager().bindThreadObject(...) to bind the SingleConnectionDatasource to the thread, before using the JDBCTemplate, but I'm not sure that's buying me much over the case of not binding it. In either case, JDBCTemplate is simply going to end up getting the same Connection. Because I am using the SingleConnectionDatasource, it's not like in this case there is a real DataSource object, and you only want to call getConnection on it once... Hopefully my exaplanation is clear now... jürgen höller [werk3AT] wrote: >I agree that in case of an existing connection, SingleConnectionDataSource should not override the commit mode. For the default case, I consider auto commit mode appropriate though. Any J2EE DataSource will return an auto commit connection outside a transaction, so why shouldn't SingleConnectionDataSource do too? > >BTW, what you are trying to do seems a bit awkward. Why manually feed the Connection of a Hibernate Session via SingleConnectionDataSource to JdbcTemplate? JdbcTemplate is supposed to be a threadsafe, reusable object, fetching connections on demand. Wouldn't it be easier to use Spring's thread-binding mechanism (DataSourceUtils.getThreadObjectManager) to make JdbcTemplate use a specific connection, be it implicitly via HibernateTransactionManager or explicitly in some custom way? > >Juergen > > > > -----Ursprüngliche Nachricht----- > Von: Colin Sampaleanu [mailto:col...@ex...] > Gesendet: Mo 25.08.2003 20:02 > An: spr...@li... > Cc: > Betreff: [Springframework-developer] Why does SingleConnectionDataSource always set autoCommit=true? > > > > I want to use SingleConnectionDataSource with Hibernate, so I can wrap a > connection I get from a Hibernate Session, and feed it as a DataSource > to JDBCTemplate/JDBCHelper. > > However, right now I've had to make my own variant since the current > code always calls > source.setAutoCommit(true); > in the init() method. This seems very arbitrary to me. At least in the > case when the class is given an existing connection, it should just > assume the commit option has been set appropriately on the connection. > > Even in the case when the class is opening the connection itself from an > existing DataSource, there needs to be an option to set autoCommit > either way. > > Regards, > Colin > > |
|
From: <jue...@we...> - 2003-08-25 22:36:30
|
PiBTaW5jZSBpbiB0aGlzIGNhc2UgdGhlIERhdGFTb3VyY2UgaXMgbm90IGFscmVhZHkgYm91bmQg dG8gdGhlIHRocmVhZCwgaW4gdGhpcyBjYXNlLCBteSBKREJDIGNvZGUgZW5kcyB1cCBjYWxsaW5n IGdldENvbm5lY3Rpb24gb24gdGhlIHJlYWwgRGF0YVNvdXJjZSAoZnJvbSBKTkRJKS4gVGhlbiB0 aGF0IGRhdGFzb3VyY2UgZW5kcyB1cCBhbGxvY2F0aW5nIGEgbmV3IGNvbm5lY3Rpb24gZnJvbSBp dHMgcG9vbCwgd2hpY2ggaXMgcmV0dXJuZWQgdG8gbWUuIFRoZXJlIGlzIG5vIGlzc3VlIGluIHRl cm1zIG9mIHdvcmtpbmcgdG9nZXRoZXIgd2l0aCB0aGUgZXhpc3RpbmcgY29ubmVjdGlvbiwgSlRB IHRha2VzIGNhcmUgb2YgdGhhdCwgYnV0IHRoZSB3aG9sZSBwcm9jZXNzIGlzIGEgbG90IG1vcmUg aGVhdnl3ZWlnaHQgYW5kIHRha2VzIG1vcmUgcmVzb3VyY2VzICh0d28gcG9vbGVkIGNvbm5lY3Rp b25zIGluc3RlYWQgb2Ygb25lKSwgcGx1cyB0aGUgY29vcmRpbmF0aW9uIGFtb25nIHRoZW0uDQog DQpUbyB0aGUgYmVzdCBvZiBteSBrbm93bGVkZ2UsIGFueSBkZWNlbnQgSlRBIGltcGxlbWVudGF0 aW9uIHdpbGwgcmV0dXJuIHRoZSBzYW1lIENvbm5lY3Rpb24gaW5zdGFuY2UgaWYgYXNrZWQgZm9y IGEgQ29ubmVjdGlvbiBmb3IgdGhlIHNhbWUgRGF0YVNvdXJjZSBhZ2FpbiB3aXRoaW4gYW4gYWN0 aXZlIHRyYW5zYWN0aW9uLiBUaGlzIGlzIGV2ZW4gcmVjb21tZW5kZWQgYnkgdGhlIEpUQSBzcGVj LCB1bmRlciB0aGUgbmFtZSAibG9jYWwgdHJhbnNhY3Rpb24gb3B0aW1pemF0aW9uIiBJSVJDLiBK VEEgdHJhbnNhY3Rpb24gbWFuYWdlcnMgd2lsbCB0eXBpY2FsbHkgbm90IHBlcmZvcm0gMlBDIGZv ciBzdWNoIHNpbmdsZSBEYXRhU291cmNlIHRyYW5zYWN0aW9ucyBidXQganVzdCBmb3IgYWN0dWFs IGRpc3RyaWJ1dGVkIG9uZXMuIEkgY29uc2lkZXIgaXQgc2FmZSB0byBhc3N1bWUgdGhhdCBhbGwg bWFqb3IgY29udGFpbmVycyBpbXBsZW1lbnQgaXQgdGhhdCB3YXkuDQogDQpKdWVyZ2VuDQoNCg0K asO8cmdlbiBow7ZsbGVyIFt3ZXJrM0FUXSB3cm90ZToNCg0KPkNvbGluLA0KPg0KPllvdSBvYnZp b3VzbHkgd2FudCB0byBwZXJmb3JtIHBsYWluIEpEQkMgYWNjZXNzIHdpdGhpbiB0aGUgc2FtZSB0 cmFuc2FjdGlvbiBhcyB0aGUgSGliZXJuYXRlIGFjY2Vzcy4gVGhpcyBjYW4gYmUgYWNoaWV2ZWQg ZWFzaWx5IHZpYSBIaWJlcm5hdGVUcmFuc2FjdGlvbk1hbmFnZXIgb3IgSnRhVHJhbnNhY3Rpb25N YW5hZ2VyLCB3aXRob3V0IGFueSBzcGVjaWZpYyBnbHVpbmcuDQo+DQo+SWYgeW91IGRlZmluZSBh IHJlc3BlY3RpdmUgSkRCQyBEYXRhU291cmNlIGluIHRoZSBhcHBsaWNhdGlvbiBjb250ZXh0LCBw b2ludGluZyB0byB0aGUgc2FtZSBvbmUgdGhhdCBIaWJlcm5hdGUgdXNlcyAoYmUgaXQgYSBsb2Nh bCBvbmUgc3BlY2lmaWVkIG9uIExvY2FsU2Vzc2lvbkZhY3RvcnlCZWFuIG9yIGEgc2hhcmVkIEpO REkgb25lKSwgeW91IGNhbiBtYWtlIEhpYmVybmF0ZVRyYW5zYWN0aW9uTWFuYWdlciBleHBvcnQg aXRzIHRyYW5zYWN0aW9ucyBmb3IgdGhpcyBwYXJ0aWN1bGFyIERhdGFTb3VyY2UgYnkgcGFzc2lu ZyB0aGUgRGF0YVNvdXJjZSBhcyBiZWFuIHJlZmVyZW5jZSBpbnRvIGl0cyAiZGF0YVNvdXJjZSIg cHJvcGVydHkuIEhpYmVybmF0ZVRyYW5zYWN0aW9uTWFuYWdlciB3aWxsIHNpbXBseSB0YWtlIHRo ZSB2ZXJ5IEpEQkMgQ29ubmVjdGlvbiB0aGF0IHRoZSBIaWJlcm5hdGUgU2Vzc2lvbiB1c2VzIGFu ZCBiaW5kIGl0IHRvIHRoZSB0aHJlYWQgdmlhIERhdGFTb3VyY2VVdGlscyBmb3IgcGxhaW4gSkRC QyBhY2Nlc3Mgb24gdGhhdCBEYXRhU291cmNlLiBUaGUgbGF0dGVyIGRvZXMgbm90IGhhdmUgdG8g YmUgYXdhcmUgdGhhdCBpdCBpcyB3b3JraW5nIHdpdGggYSBIaWJlcm5hdGUtcHJvdmlkZWQgQ29u bmVjdGlvbiENCj4NCj5XaXRoIEp0YVRyYW5zYWN0aW9uTWFuYWdlciwgaXQncyBzaW1pbGFyOiBE ZWZpbmUgdGhlIHNhbWUgSk5ESSBEYXRhU291cmNlIHRoYXQgdGhlIEhpYmVybmF0ZSBTZXNzaW9u RmFjdG9yeSB1c2VzIGZvciB0aGUgSmRiY1RlbXBsYXRlLCBhbmQgSlRBIHdpbGwgY2FyZSBmb3Ig cmV0dXJuaW5nIHRoZSBzYW1lIENvbm5lY3Rpb24gdG8gYm90aCB0aGUgSGliZXJuYXRlIFNlc3Np b24gYW5kIHRoZSBKREJDIGFjY2VzcyBjb2RlIGlmIGluIGFuIGFjdGl2ZSB0cmFuc2FjdGlvbi4N Cj4NCj5TbyBpbiBhbnkgY2FzZSwgdGhpcyAic2FtZSBEYXRhU291cmNlIiBhcHByb2FjaCBpcyBh cyBlZmZpY2llbnQgYXMgcGFzc2luZyB0aGUgSGliZXJuYXRlIFNlc3Npb24ncyBKREJDIENvbm5l Y3Rpb24gbWFudWFsbHkgdG8gYSBKZGJjVGVtcGxhdGUgaW5zdGFuY2UsIGFzIGl0IHJldXNlcyB0 aGUgc2FtZSBDb25uZWN0aW9uIGZvciBib3RoIHRoZSBIaWJlcm5hdGUgU2Vzc2lvbiBhbmQgdGhl IEpkYmNUZW1wbGF0ZSB3aXRoaW4gYSB0cmFuc2FjdGlvbi4gSSBzdHJvbmdseSByZWNvbW1lbmQg c3VjaCBhIHNvbHV0aW9uIG92ZXIgbWFudWFsIGdsdWluZy4NCj4NCj5KdWVyZ2VuDQo+DQo+DQo+ DQo+ICAgICAgIC0tLS0tVXJzcHLDvG5nbGljaGUgTmFjaHJpY2h0LS0tLS0NCj4gICAgICAgVm9u OiBDb2xpbiBTYW1wYWxlYW51IFttYWlsdG86Y29saW5tbDFAZXhpcy5jb21dDQo+ICAgICAgIEdl c2VuZGV0OiBNbyAyNS4wOC4yMDAzIDIzOjE0DQo+ICAgICAgIEFuOiBqw7xyZ2VuIGjDtmxsZXIg W3dlcmszQVRdDQo+ICAgICAgIENjOiBzcHJpbmdmcmFtZXdvcmstZGV2ZWxvcGVyQGxpc3RzLnNv dXJjZWZvcmdlLm5ldA0KPiAgICAgICBCZXRyZWZmOiBSZTogW1NwcmluZ2ZyYW1ld29yay1kZXZl bG9wZXJdIFdoeSBkb2VzIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIGFsd2F5cyBzZXQgYXV0 b0NvbW1pdD10cnVlPw0KPiAgICAgIA0KPiAgICAgIA0KPg0KPiAgICAgICBXL3JlZ2FyZHMgdG8g YXV0byBjb21taXQgaW4gdGhlIGRlZmF1bHQgY2FzZSAod2hlbiB0aGUgY2xhc3MgZ2V0cyB0aGUN Cj4gICAgICAgY29ubmVjdGlvbiBpdHNlbGYpLCBJIHdvdWxkIHNheSwgZXhhY3RseSwgdGhlIEpE QkMgc3BlY3Mgc3BlY2lmaWNhbGx5DQo+ICAgICAgIHNheSB0aGUgZ2V0Q29ubmVjdGlvbiBjYWxs ZWQgb24gdGhlIGRhdGFzb3VyY2Ugd2lsbCByZXR1cm4gYSBjb25uZWN0aW9uDQo+ICAgICAgIHdp dGggYXV0b0NvbW1pdCBvbiBieSBkZWZhdWx0LiBTbyB3aHkgaXMgU2luZ2xlQ29ubmVjdGlvbkRh dGFTb3VyY2UgdGhlbg0KPiAgICAgICBnb2luZyBhbmQgc2V0dGluZyBpdCBvbiBhcyB3ZWxsLiBH aXZlbiB0aGF0IFNpbmdsZUNvbm5lY3Rpb25EYXRhc291cmNlDQo+ICAgICAgIGRvZXNuJ3QgaGF2 ZSBhbnkgY2x1ZSBhYm91dCB0aGUgaW50ZW5kZWQgdXNlIG9mIHRoZSBjb25uZWN0aW9uLCB0aGUg bW9zdA0KPiAgICAgICBjb3JyZWN0IGJlaGF2aW91ciBpcyBwcm9iYWJseSB0byBub3QgaGF2ZSBp dCBjYWxsIHNldEF1dG9Db21taXQgd2l0aA0KPiAgICAgICBlaXRoZXIgc3RhdGUsIGJ5IGRlZmF1 bHQsIHdoaWNoIHdvdWxkIG1pcnJvciBub3JtYWwNCj4gICAgICAgZGF0YXNvdXJjZS9jb25uZWN0 aW9uIHVzYWdlLCBhbmQgYWxzbyBhbGxvdyBhIG1lY2hhbmlzbSB0byBzcGVjaWZ5IHRoYXQNCj4g ICAgICAgaXQgc2hvdWxkIGJlIGNhbGxlZCBvbmUgd2F5IG9yIGFub3RoZXIuIEhvd2V2ZXIsIHRo aXMgbWF5IGJlIG1vcmUgd29yaw0KPiAgICAgICB0aGFuIGlzIHdvcnRoIGl0LCBhbmQgYSBkZWZh dWx0IGNhbGwgd2l0aCB0aGUgb3B0aW9uIHRvIG9uLCBhbG9uZyB3aXRoIGENCj4gICAgICAgbWVj aGFuaXNtIChhbm90aGVyIGNvbnN0cnVjdG9yIHdpdGggYSB2YWx1ZSBmb3IgdGhlIGNhbGwpIHRv IG92ZXJyaWRlDQo+ICAgICAgIGl0LCB3b3VsZCBiZSBmaW5lLiBTbyB0byBiZSBjbGVhciwgSSBk byB0aGluayBldmVuIHdoZW4NCj4gICAgICAgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2UgZ2V0 cyB0aGUgY29ubmVjdGlvbiB0aGVyZSBpcyBhIG5lZWQgZm9yIGFuDQo+ICAgICAgIG92ZXJyaWRl Lg0KPiAgICAgIA0KPiAgICAgICBBcyBmb3IgbXkgdXNlIGNhc2UsIEkgZG9uJ3QgdGhpbmsgSSB3 YXMgY2xlYXIgZW5vdWdoLiAgSSBoYXZlIHNvbWUgY29kZQ0KPiAgICAgICBpbiBhIEhpYmVybmF0 ZSBzcGVjaWZpYyBEQU8vTWFwcGVyIG9iamVjdC4gSSBhbSBhbHJlYWR5IGV4ZWN1dGluZyBpbnNp ZGUNCj4gICAgICAgYSB0cmFuc2FjdGlvbiBpbnRyb2R1Y2VkIHZpYSBTcHJpbmcncyBBT1AgaW50 ZXJjZXB0b3IuIFNvIEkgZG8gaGF2ZSBhDQo+ICAgICAgIFNlc3Npb25GYWN0b3J5LCBldGMuIGJv dW5kIHRvIHRoZSB0aHJlYWQuIE5vdyBpbnNpZGUgYSBtZXRob2QgaW4gdGhpcw0KPiAgICAgICBt YXBwZXIgSSBuZWVkIHRvIGRvIGFuIG9wZXJhdGlvbiBvbiBhIEJMT0IvQ0xPQiwgd2hlcmUgdGhl cmUgYXJlIGENCj4gICAgICAgbnVtYmVyIG9mIGRiIHBsYXRmb3JtIHNwZWNpZmljIGlzc3Vlcywg YW5kIEhpYmVybmF0ZSdzIHN1cHBvcnQgb2YNCj4gICAgICAgQkxPQnMvQ0xPQnMgaXMgbm90IGdv b2QgZW5vdWdoLiBHaXZlbiB0aGF0IEkgaGF2ZSBhIEhpYmVybmF0ZSBTZXNzaW9uDQo+ICAgICAg IHdoaWNoIGFscmVhZHkgaGFzIGEgY29ubmVjdGlvbiBhdmFpbGFibGUsIHVzaW5nIGl0IGlzIHRo ZSBiZXN0IG1lY2hhbmlzbQ0KPiAgICAgICAoYXMgb3Bwb3NlZCB0byB0cnlpbmcgdG8gZ2V0IGEg cmVhbCBEYXRhU291cmNlIGluIFNwcmluZydzIGNvbnRleHQgdG8NCj4gICAgICAgdXNlKS4gTm93 IEkgYW0gdXNpbmcgSkRCQ1RlbXBsYXRlIGFuZCBKREJDSGVscGVyIGFzIGNvbnZlbmllbmNlIGNs YXNzZXMsDQo+ICAgICAgIHRvIHdyYXAgSkRCQyBleGNlcHRpb25zLCBhbmQgZm9yIHRoZSBtZXRo b2RzIHRoZXkgcHJvdmlkZS4gTm93IEkgY291bGQgY2FsbA0KPiAgICAgICAgIERhdGFTb3VyY2VV dGlscy5nZXRUaHJlYWRPYmplY3RNYW5hZ2VyKCkuYmluZFRocmVhZE9iamVjdCguLi4pDQo+ICAg ICAgIHRvIGJpbmQgdGhlIFNpbmdsZUNvbm5lY3Rpb25EYXRhc291cmNlIHRvIHRoZSB0aHJlYWQs IGJlZm9yZSB1c2luZyB0aGUNCj4gICAgICAgSkRCQ1RlbXBsYXRlLCBidXQgSSdtIG5vdCBzdXJl IHRoYXQncyBidXlpbmcgbWUgbXVjaCBvdmVyIHRoZSBjYXNlIG9mDQo+ICAgICAgIG5vdCBiaW5k aW5nIGl0LiBJbiBlaXRoZXIgY2FzZSwgSkRCQ1RlbXBsYXRlIGlzIHNpbXBseSBnb2luZyB0byBl bmQgdXANCj4gICAgICAgZ2V0dGluZyB0aGUgc2FtZSBDb25uZWN0aW9uLiBCZWNhdXNlIEkgYW0g dXNpbmcgdGhlDQo+ICAgICAgIFNpbmdsZUNvbm5lY3Rpb25EYXRhc291cmNlLCBpdCdzIG5vdCBs aWtlIGluIHRoaXMgY2FzZSB0aGVyZSBpcyBhIHJlYWwNCj4gICAgICAgRGF0YVNvdXJjZSBvYmpl Y3QsIGFuZCB5b3Ugb25seSB3YW50IHRvIGNhbGwgZ2V0Q29ubmVjdGlvbiBvbiBpdCBvbmNlLi4u DQo+ICAgICAgDQo+ICAgICAgIEhvcGVmdWxseSBteSBleGFwbGFuYXRpb24gaXMgY2xlYXIgbm93 Li4uDQo+ICAgICAgDQo+ICAgICAgDQo+ICAgICAgIGrDvHJnZW4gaMO2bGxlciBbd2VyazNBVF0g d3JvdGU6DQo+ICAgICAgDQo+ICAgICAgID5JIGFncmVlIHRoYXQgaW4gY2FzZSBvZiBhbiBleGlz dGluZyBjb25uZWN0aW9uLCBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJjZSBzaG91bGQgbm90IG92 ZXJyaWRlIHRoZSBjb21taXQgbW9kZS4gRm9yIHRoZSBkZWZhdWx0IGNhc2UsIEkgY29uc2lkZXIg YXV0byBjb21taXQgbW9kZSBhcHByb3ByaWF0ZSB0aG91Z2guIEFueSBKMkVFIERhdGFTb3VyY2Ug d2lsbCByZXR1cm4gYW4gYXV0byBjb21taXQgY29ubmVjdGlvbiBvdXRzaWRlIGEgdHJhbnNhY3Rp b24sIHNvIHdoeSBzaG91bGRuJ3QgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2UgZG8gdG9vPw0K PiAgICAgICA+DQo+ICAgICAgID5CVFcsIHdoYXQgeW91IGFyZSB0cnlpbmcgdG8gZG8gc2VlbXMg YSBiaXQgYXdrd2FyZC4gV2h5IG1hbnVhbGx5IGZlZWQgdGhlIENvbm5lY3Rpb24gb2YgYSBIaWJl cm5hdGUgU2Vzc2lvbiB2aWEgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2UgdG8gSmRiY1RlbXBs YXRlPyBKZGJjVGVtcGxhdGUgaXMgc3VwcG9zZWQgdG8gYmUgYSB0aHJlYWRzYWZlLCByZXVzYWJs ZSBvYmplY3QsIGZldGNoaW5nIGNvbm5lY3Rpb25zIG9uIGRlbWFuZC4gV291bGRuJ3QgaXQgYmUg ZWFzaWVyIHRvIHVzZSBTcHJpbmcncyB0aHJlYWQtYmluZGluZyBtZWNoYW5pc20gKERhdGFTb3Vy Y2VVdGlscy5nZXRUaHJlYWRPYmplY3RNYW5hZ2VyKSB0byBtYWtlIEpkYmNUZW1wbGF0ZSB1c2Ug YSBzcGVjaWZpYyBjb25uZWN0aW9uLCBiZSBpdCBpbXBsaWNpdGx5IHZpYSBIaWJlcm5hdGVUcmFu c2FjdGlvbk1hbmFnZXIgb3IgZXhwbGljaXRseSBpbiBzb21lIGN1c3RvbSB3YXk/DQo+ICAgICAg ID4NCj4gICAgICAgPkp1ZXJnZW4NCj4gICAgICAgPg0KPiAgICAgICA+DQo+ICAgICAgID4NCj4g ICAgICAgPiAgICAgICAtLS0tLVVyc3Byw7xuZ2xpY2hlIE5hY2hyaWNodC0tLS0tDQo+ICAgICAg ID4gICAgICAgVm9uOiBDb2xpbiBTYW1wYWxlYW51IFttYWlsdG86Y29saW5tbDFAZXhpcy5jb21d DQo+ICAgICAgID4gICAgICAgR2VzZW5kZXQ6IE1vIDI1LjA4LjIwMDMgMjA6MDINCj4gICAgICAg PiAgICAgICBBbjogc3ByaW5nZnJhbWV3b3JrLWRldmVsb3BlckBsaXN0cy5zb3VyY2Vmb3JnZS5u ZXQNCj4gICAgICAgPiAgICAgICBDYzoNCj4gICAgICAgPiAgICAgICBCZXRyZWZmOiBbU3ByaW5n ZnJhbWV3b3JrLWRldmVsb3Blcl0gV2h5IGRvZXMgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2Ug YWx3YXlzIHNldCBhdXRvQ29tbWl0PXRydWU/DQo+ICAgICAgID4gICAgIA0KPiAgICAgICA+ICAg ICANCj4gICAgICAgPg0KPiAgICAgICA+ICAgICAgIEkgd2FudCB0byB1c2UgU2luZ2xlQ29ubmVj dGlvbkRhdGFTb3VyY2Ugd2l0aCBIaWJlcm5hdGUsIHNvIEkgY2FuIHdyYXAgYQ0KPiAgICAgICA+ ICAgICAgIGNvbm5lY3Rpb24gSSBnZXQgZnJvbSBhIEhpYmVybmF0ZSBTZXNzaW9uLCBhbmQgZmVl ZCBpdCBhcyBhIERhdGFTb3VyY2UNCj4gICAgICAgPiAgICAgICB0byBKREJDVGVtcGxhdGUvSkRC Q0hlbHBlci4NCj4gICAgICAgPiAgICAgDQo+ICAgICAgID4gICAgICAgSG93ZXZlciwgcmlnaHQg bm93IEkndmUgaGFkIHRvIG1ha2UgbXkgb3duIHZhcmlhbnQgc2luY2UgdGhlIGN1cnJlbnQNCj4g ICAgICAgPiAgICAgICBjb2RlIGFsd2F5cyBjYWxscw0KPiAgICAgICA+ICAgICAgICAgc291cmNl LnNldEF1dG9Db21taXQodHJ1ZSk7DQo+ICAgICAgID4gICAgICAgaW4gdGhlIGluaXQoKSBtZXRo b2QuICBUaGlzIHNlZW1zIHZlcnkgYXJiaXRyYXJ5IHRvIG1lLiBBdCBsZWFzdCBpbiB0aGUNCj4g ICAgICAgPiAgICAgICBjYXNlIHdoZW4gdGhlIGNsYXNzIGlzIGdpdmVuIGFuIGV4aXN0aW5nIGNv bm5lY3Rpb24sIGl0IHNob3VsZCBqdXN0DQo+ICAgICAgID4gICAgICAgYXNzdW1lIHRoZSBjb21t aXQgb3B0aW9uIGhhcyBiZWVuIHNldCBhcHByb3ByaWF0ZWx5IG9uIHRoZSBjb25uZWN0aW9uLg0K PiAgICAgICA+ICAgICANCj4gICAgICAgPiAgICAgICBFdmVuIGluIHRoZSBjYXNlIHdoZW4gdGhl IGNsYXNzIGlzIG9wZW5pbmcgdGhlIGNvbm5lY3Rpb24gaXRzZWxmIGZyb20gYW4NCj4gICAgICAg PiAgICAgICBleGlzdGluZyBEYXRhU291cmNlLCB0aGVyZSBuZWVkcyB0byBiZSBhbiBvcHRpb24g dG8gc2V0IGF1dG9Db21taXQNCj4gICAgICAgPiAgICAgICBlaXRoZXIgd2F5Lg0KPiAgICAgICA+ ICAgICANCj4gICAgICAgPiAgICAgICBSZWdhcmRzLA0KPiAgICAgICA+ICAgICAgIENvbGluDQo+ ICAgICAgID4gICAgIA0KPiAgICAgICA+DQo+ICAgICAgDQo+ICAgICAgDQo+ICAgICAgDQo+DQo+ IA0KPg0KDQoNCg0K |
|
From: Colin S. <col...@ex...> - 2003-08-26 02:29:48
|
I am anything but an expert in this area unfortunately, but after thinking about it, from my point of view, it's somewhat of a wash as to which approach is 'cleaner'. There is a very simple requirement and use case here. You already have a connection object, and at the same location are creating another object which under ideal circumstances uses the very same connection, and should get it with as little work as possible. So in your ideal use scenario of using the real datasource, you can rely on the fact that asking your container (somwhat more indirectly) for a connection from that datasource, will get you the same connection. But it's actually out of your control and there's not necessarily much you can do about it if the container doesn't do this, in which case your are looking at a potentially much less efficient result. I've found two references to the possiblity that maybe OC4J and the Advanced container in WebSphere don't do the local transaction optimization: (search for 6.12) http://otn.oracle.com/tech/java/oc4j/doc_library/902/servicesjun02/jca.htm http://www-3.ibm.com/software/webservers/appserv/doc/v40/ae/infocenter/was/040901.html So I think in this particular case the use of the 'real' DataSource just complicates things without really adding any advtantages. It's not making testing easier, it's not providing better separation of concerns (the contrary, I would say, actually), etc. In any case, this is somewhat orthogonal to the original post which was about the need to allow the autoComit flag to go either way on the connection obtained from SingleConnectionDataSource, whether or not it was given an existing connection or gets it through DriverManager. Hopefully we are both in agreement that the option is needed in this class. Regards, Colin jürgen höller [werk3AT] wrote: >>Since in this case the DataSource is not already bound to the thread, in this case, my JDBC code ends up calling getConnection on the real DataSource (from JNDI). Then that datasource ends up allocating a new connection from its pool, which is returned to me. There is no issue in terms of working together with the existing connection, JTA takes care of that, but the whole process is a lot more heavyweight and takes more resources (two pooled connections instead of one), plus the coordination among them. >> >> > >To the best of my knowledge, any decent JTA implementation will return the same Connection instance if asked for a Connection for the same DataSource again within an active transaction. This is even recommended by the JTA spec, under the name "local transaction optimization" IIRC. JTA transaction managers will typically not perform 2PC for such single DataSource transactions but just for actual distributed ones. I consider it safe to assume that all major containers implement it that way. > >Juergen > > >jürgen höller [werk3AT] wrote: > > > >>Colin, >> >>You obviously want to perform plain JDBC access within the same transaction as the Hibernate access. This can be achieved easily via HibernateTransactionManager or JtaTransactionManager, without any specific gluing. >> >>If you define a respective JDBC DataSource in the application context, pointing to the same one that Hibernate uses (be it a local one specified on LocalSessionFactoryBean or a shared JNDI one), you can make HibernateTransactionManager export its transactions for this particular DataSource by passing the DataSource as bean reference into its "dataSource" property. HibernateTransactionManager will simply take the very JDBC Connection that the Hibernate Session uses and bind it to the thread via DataSourceUtils for plain JDBC access on that DataSource. The latter does not have to be aware that it is working with a Hibernate-provided Connection! >> >>With JtaTransactionManager, it's similar: Define the same JNDI DataSource that the Hibernate SessionFactory uses for the JdbcTemplate, and JTA will care for returning the same Connection to both the Hibernate Session and the JDBC access code if in an active transaction. >> >>So in any case, this "same DataSource" approach is as efficient as passing the Hibernate Session's JDBC Connection manually to a JdbcTemplate instance, as it reuses the same Connection for both the Hibernate Session and the JdbcTemplate within a transaction. I strongly recommend such a solution over manual gluing. >> >>Juergen >> >> >> >> -----Ursprüngliche Nachricht----- >> Von: Colin Sampaleanu [mailto:col...@ex...] >> Gesendet: Mo 25.08.2003 23:14 >> An: jürgen höller [werk3AT] >> Cc: spr...@li... >> Betreff: Re: [Springframework-developer] Why does SingleConnectionDataSource always set autoCommit=true? >> >> >> >> W/regards to auto commit in the default case (when the class gets the >> connection itself), I would say, exactly, the JDBC specs specifically >> say the getConnection called on the datasource will return a connection >> with autoCommit on by default. So why is SingleConnectionDataSource then >> going and setting it on as well. Given that SingleConnectionDatasource >> doesn't have any clue about the intended use of the connection, the most >> correct behaviour is probably to not have it call setAutoCommit with >> either state, by default, which would mirror normal >> datasource/connection usage, and also allow a mechanism to specify that >> it should be called one way or another. However, this may be more work >> than is worth it, and a default call with the option to on, along with a >> mechanism (another constructor with a value for the call) to override >> it, would be fine. So to be clear, I do think even when >> SingleConnectionDataSource gets the connection there is a need for an >> override. >> >> As for my use case, I don't think I was clear enough. I have some code >> in a Hibernate specific DAO/Mapper object. I am already executing inside >> a transaction introduced via Spring's AOP interceptor. So I do have a >> SessionFactory, etc. bound to the thread. Now inside a method in this >> mapper I need to do an operation on a BLOB/CLOB, where there are a >> number of db platform specific issues, and Hibernate's support of >> BLOBs/CLOBs is not good enough. Given that I have a Hibernate Session >> which already has a connection available, using it is the best mechanism >> (as opposed to trying to get a real DataSource in Spring's context to >> use). Now I am using JDBCTemplate and JDBCHelper as convenience classes, >> to wrap JDBC exceptions, and for the methods they provide. Now I could call >> DataSourceUtils.getThreadObjectManager().bindThreadObject(...) >> to bind the SingleConnectionDatasource to the thread, before using the >> JDBCTemplate, but I'm not sure that's buying me much over the case of >> not binding it. In either case, JDBCTemplate is simply going to end up >> getting the same Connection. Because I am using the >> SingleConnectionDatasource, it's not like in this case there is a real >> DataSource object, and you only want to call getConnection on it once... >> >> Hopefully my exaplanation is clear now... >> >> >> jürgen höller [werk3AT] wrote: >> >> >I agree that in case of an existing connection, SingleConnectionDataSource should not override the commit mode. For the default case, I consider auto commit mode appropriate though. Any J2EE DataSource will return an auto commit connection outside a transaction, so why shouldn't SingleConnectionDataSource do too? >> > >> >BTW, what you are trying to do seems a bit awkward. Why manually feed the Connection of a Hibernate Session via SingleConnectionDataSource to JdbcTemplate? JdbcTemplate is supposed to be a threadsafe, reusable object, fetching connections on demand. Wouldn't it be easier to use Spring's thread-binding mechanism (DataSourceUtils.getThreadObjectManager) to make JdbcTemplate use a specific connection, be it implicitly via HibernateTransactionManager or explicitly in some custom way? >> > >> >Juergen >> > >> > >> > >> > -----Ursprüngliche Nachricht----- >> > Von: Colin Sampaleanu [mailto:col...@ex...] >> > Gesendet: Mo 25.08.2003 20:02 >> > An: spr...@li... >> > Cc: >> > Betreff: [Springframework-developer] Why does SingleConnectionDataSource always set autoCommit=true? >> > >> > >> > >> > I want to use SingleConnectionDataSource with Hibernate, so I can wrap a >> > connection I get from a Hibernate Session, and feed it as a DataSource >> > to JDBCTemplate/JDBCHelper. >> > >> > However, right now I've had to make my own variant since the current >> > code always calls >> > source.setAutoCommit(true); >> > in the init() method. This seems very arbitrary to me. At least in the >> > case when the class is given an existing connection, it should just >> > assume the commit option has been set appropriately on the connection. >> > >> > Even in the case when the class is opening the connection itself from an >> > existing DataSource, there needs to be an option to set autoCommit >> > either way. >> > >> > Regards, >> >> |
|
[Springframework-developer] Patch for SingleConnectionDataSource.java to allow setAutoCommit
control
From: Colin S. <col...@ex...> - 2003-08-26 03:44:20
Attachments:
SingleConnectionDataSource.java.patch
|
Here's a patch for SingleConnectionDataSource which allows the setAutoCommit call to be controlled, as per earlier discussion. By default, the class will no longer call setCommit at all if an existing connection is given to it in the constructor. Otherwise it will behave the same as before by default (i.e. if the connection is obtained from DriveManager then setAutoCommit(true) is called). There are flags to control the calling of setAutoCommit and the initial state. As to whether the class should even allow overriding this when the connection comes from DriverManger; it's true that most people would expect the state to be autocommit=true as per the Connection javadocs, but on the other hand the code was simpler this way, and maybe the extra flexibility will help in testing... Regards, Colin |
|
From: <jue...@we...> - 2003-08-26 08:26:21
|
SSBhZ3JlZSB0aGF0IGZvciBhbiBpbnRlZ3JhdGVkIGRhdGEgYWNjZXNzIHVuaXQgb2Ygd29yayBp dCBtYWtlcyBzZW5zZSB0byBhdm9pZCB0aGUgc2VwYXJhdGUgdHJhbnNhY3Rpb25hbCBjb25uZWN0 aW9uIGxvb2t1cCBhbmQgc2ltcGx5IGZlZWQgdGhlIGdpdmVuIGNvbm5lY3Rpb24gdG8gSmRiY1Rl bXBsYXRlLiBJJ2xsIHBhdGNoIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIGFjY29yZGluZ2x5 IHRvZGF5Lg0KIA0KTm90ZSB0aGF0IHRoZSBzZXR1cCB3aXRoIGEgZGVkaWNhdGVkIERhdGFTb3Vy Y2UgdGhhdCBJJ3ZlIHByb3Bvc2VkIGlzIGFwcHJvcHJpYXRlIHdoZW4gdGhlIEhpYmVybmF0ZSBh Y2Nlc3MgY29kZSBhbmQgdGhlIEpEQkMgYWNjZXNzIGNvZGUgYXJlIGluIGRpZmZlcmVudCBEQU9z LCBvciBpbiBkaWZmZXJlbnQgcHVibGljIG1ldGhvZHMgb2YgdGhlIHNhbWUgREFPLiBGb3IgcHJv cGVyIGxvb3NlIGNvdXBsaW5nLCBuZWl0aGVyIHNob3VsZCBoYXZlIHRvIGtub3cgYWJvdXQgdGhl IG90aGVyLiBFYWNoIHNpbXBseSBsb29rcyB1cCBpdHMgU2Vzc2lvbkZhY3Rvcnkgb3IgRGF0YVNv dXJjZSBhbmQgcGVyZm9ybXMgaXRzIHdvcmsuIFRoZSB0cmFuc2FjdGlvbiBtYW5hZ2VyIGNhcmVz IGZvciB0aGUgcHJvcGVyIGdsdWluZy4gQWZ0ZXIgYWxsLCBlYWNoIERBTyBtZXRob2QgY291bGQg YWxzbyBiZSB1c2VkIG9uIGl0cyBvd24gb3Igd2l0aGluIGEgZGlmZmVyZW50IHVuaXQgb2Ygd29y ay4NCiANClJlZ2FyZGluZyBKVEEgc3VwcG9ydCBpbiBPQzRKIGFuZCBXZWJTcGhlcmU6IEJvdGgg bGltaXRhdGlvbnMgd2VyZSBzcGVjaWZpY2FsbHkgZm9yIEpDQSBhZGFwdGVycy4gSSBzdGlsbCBh c3N1bWUgdGhhdCBib3RoIGRvIGxvY2FsIHRyYW5zYWN0aW9uIG9wdGltaXphdGlvbiBvbiBKREJD IERhdGFTb3VyY2VzLCBhcyB0aGlzIGlzIHRoZSBtb3N0IHByb21pbmVudCB1c2UgY2FzZSwgd2hp bGUgSkNBIGlzIGJhc2ljYWxseSBhbiBhZnRlcnRob3VnaHQgKGF0IGxlYXN0IGZvciB0aGVtKS4N CiANCklmIHlvdSdyZSBkb2luZyB0cmFuc2FjdGlvbnMgdGhhdCBzcGFuIG9uZSBzaW5nbGUgZGF0 YWJhc2UgYnV0IEhpYmVybmF0ZSBhbmQgSkRCQyBhY2Nlc3MgY29kZSwgSGliZXJuYXRlVHJhbnNh Y3Rpb25NYW5hZ2VyIGlzIGRlZmluaXRlbHkgdGhlIG1vcmUgbGlnaHR3ZWlnaHQgY2hvaWNlLiBU aGVyZSdzIG5vIGNvbnZpbmNpbmcgcmVhc29uIGZvciBjaG9vc2luZyBKdGFUcmFuc2FjdGlvbk1h bmFnZXIgaW4gc3VjaCBhIHNjZW5hcmlvLCBhcyB5b3UncmUgbm90IHVzaW5nIGFueSBwYXJ0aWN1 bGFyIEpUQSBmZWF0dXJlLg0KIA0KSnVlcmdlbg0KIA0KIA0KDQoJLS0tLS1VcnNwcsO8bmdsaWNo ZSBOYWNocmljaHQtLS0tLSANCglWb246IENvbGluIFNhbXBhbGVhbnUgW21haWx0bzpjb2xpbm1s MUBleGlzLmNvbV0gDQoJR2VzZW5kZXQ6IERpIDI2LjA4LjIwMDMgMDQ6MjkgDQoJQW46IGrDvHJn ZW4gaMO2bGxlciBbd2VyazNBVF0gDQoJQ2M6IHNwcmluZ2ZyYW1ld29yay1kZXZlbG9wZXJAbGlz dHMuc291cmNlZm9yZ2UubmV0IA0KCUJldHJlZmY6IFJlOiBbU3ByaW5nZnJhbWV3b3JrLWRldmVs b3Blcl0gV2h5IGRvZXMgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2UgYWx3YXlzIHNldCBhdXRv Q29tbWl0PXRydWU/DQoJDQoJDQoNCglJIGFtIGFueXRoaW5nIGJ1dCBhbiBleHBlcnQgaW4gdGhp cyBhcmVhIHVuZm9ydHVuYXRlbHksIGJ1dCBhZnRlcg0KCXRoaW5raW5nIGFib3V0IGl0LCBmcm9t IG15IHBvaW50IG9mIHZpZXcsIGl0J3Mgc29tZXdoYXQgb2YgYSB3YXNoIGFzIHRvDQoJd2hpY2gg YXBwcm9hY2ggaXMgJ2NsZWFuZXInLg0KCQ0KCVRoZXJlIGlzIGEgdmVyeSBzaW1wbGUgcmVxdWly ZW1lbnQgYW5kIHVzZSBjYXNlIGhlcmUuIFlvdSBhbHJlYWR5IGhhdmUgYQ0KCWNvbm5lY3Rpb24g b2JqZWN0LCBhbmQgYXQgdGhlIHNhbWUgbG9jYXRpb24gYXJlIGNyZWF0aW5nIGFub3RoZXIgb2Jq ZWN0DQoJd2hpY2ggdW5kZXIgaWRlYWwgY2lyY3Vtc3RhbmNlcyB1c2VzIHRoZSB2ZXJ5IHNhbWUg Y29ubmVjdGlvbiwgYW5kDQoJc2hvdWxkIGdldCBpdCB3aXRoIGFzIGxpdHRsZSB3b3JrIGFzIHBv c3NpYmxlLiAgU28gaW4geW91ciBpZGVhbCB1c2UNCglzY2VuYXJpbyBvZiB1c2luZyB0aGUgcmVh bCBkYXRhc291cmNlLCB5b3UgY2FuIHJlbHkgb24gdGhlIGZhY3QgdGhhdA0KCWFza2luZyB5b3Vy IGNvbnRhaW5lciAoc29td2hhdCBtb3JlIGluZGlyZWN0bHkpIGZvciBhIGNvbm5lY3Rpb24gZnJv bQ0KCXRoYXQgZGF0YXNvdXJjZSwgd2lsbCBnZXQgeW91IHRoZSBzYW1lIGNvbm5lY3Rpb24uIEJ1 dCBpdCdzIGFjdHVhbGx5IG91dA0KCW9mIHlvdXIgY29udHJvbCBhbmQgdGhlcmUncyBub3QgbmVj ZXNzYXJpbHkgbXVjaCB5b3UgY2FuIGRvIGFib3V0IGl0IGlmDQoJdGhlIGNvbnRhaW5lciBkb2Vz bid0IGRvIHRoaXMsIGluIHdoaWNoIGNhc2UgeW91ciBhcmUgbG9va2luZyBhdCBhDQoJcG90ZW50 aWFsbHkgbXVjaCBsZXNzIGVmZmljaWVudCByZXN1bHQuIEkndmUgZm91bmQgdHdvIHJlZmVyZW5j ZXMgdG8gdGhlDQoJcG9zc2libGl0eSB0aGF0IG1heWJlIE9DNEogYW5kIHRoZSBBZHZhbmNlZCBj b250YWluZXIgaW4gV2ViU3BoZXJlIGRvbid0DQoJZG8gdGhlIGxvY2FsIHRyYW5zYWN0aW9uIG9w dGltaXphdGlvbjoNCgkoc2VhcmNoIGZvciA2LjEyKQ0KCSAgaHR0cDovL290bi5vcmFjbGUuY29t L3RlY2gvamF2YS9vYzRqL2RvY19saWJyYXJ5LzkwMi9zZXJ2aWNlc2p1bjAyL2pjYS5odG0NCgkg DQoJaHR0cDovL3d3dy0zLmlibS5jb20vc29mdHdhcmUvd2Vic2VydmVycy9hcHBzZXJ2L2RvYy92 NDAvYWUvaW5mb2NlbnRlci93YXMvMDQwOTAxLmh0bWwNCgkNCglTbyBJIHRoaW5rIGluIHRoaXMg cGFydGljdWxhciBjYXNlIHRoZSB1c2Ugb2YgdGhlICdyZWFsJyBEYXRhU291cmNlIGp1c3QNCglj b21wbGljYXRlcyB0aGluZ3Mgd2l0aG91dCByZWFsbHkgYWRkaW5nIGFueSBhZHZ0YW50YWdlcy4g SXQncyBub3QNCgltYWtpbmcgdGVzdGluZyBlYXNpZXIsIGl0J3Mgbm90IHByb3ZpZGluZyBiZXR0 ZXIgc2VwYXJhdGlvbiBvZiBjb25jZXJucw0KCSh0aGUgY29udHJhcnksIEkgd291bGQgc2F5LCBh Y3R1YWxseSksIGV0Yy4NCgkNCglJbiBhbnkgY2FzZSwgdGhpcyBpcyBzb21ld2hhdCBvcnRob2dv bmFsIHRvIHRoZSBvcmlnaW5hbCBwb3N0IHdoaWNoIHdhcw0KCWFib3V0IHRoZSBuZWVkIHRvIGFs bG93IHRoZSBhdXRvQ29taXQgZmxhZyB0byBnbyBlaXRoZXIgd2F5IG9uIHRoZQ0KCWNvbm5lY3Rp b24gb2J0YWluZWQgZnJvbSBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJjZSwgd2hldGhlciBvciBu b3QgaXQNCgl3YXMgZ2l2ZW4gYW4gZXhpc3RpbmcgY29ubmVjdGlvbiBvciBnZXRzIGl0IHRocm91 Z2ggRHJpdmVyTWFuYWdlci4NCglIb3BlZnVsbHkgd2UgYXJlIGJvdGggaW4gYWdyZWVtZW50IHRo YXQgdGhlIG9wdGlvbiBpcyBuZWVkZWQgaW4gdGhpcyBjbGFzcy4NCgkNCglSZWdhcmRzLA0KCUNv bGluDQoJDQoJasO8cmdlbiBow7ZsbGVyIFt3ZXJrM0FUXSB3cm90ZToNCgkNCgk+PlNpbmNlIGlu IHRoaXMgY2FzZSB0aGUgRGF0YVNvdXJjZSBpcyBub3QgYWxyZWFkeSBib3VuZCB0byB0aGUgdGhy ZWFkLCBpbiB0aGlzIGNhc2UsIG15IEpEQkMgY29kZSBlbmRzIHVwIGNhbGxpbmcgZ2V0Q29ubmVj dGlvbiBvbiB0aGUgcmVhbCBEYXRhU291cmNlIChmcm9tIEpOREkpLiBUaGVuIHRoYXQgZGF0YXNv dXJjZSBlbmRzIHVwIGFsbG9jYXRpbmcgYSBuZXcgY29ubmVjdGlvbiBmcm9tIGl0cyBwb29sLCB3 aGljaCBpcyByZXR1cm5lZCB0byBtZS4gVGhlcmUgaXMgbm8gaXNzdWUgaW4gdGVybXMgb2Ygd29y a2luZyB0b2dldGhlciB3aXRoIHRoZSBleGlzdGluZyBjb25uZWN0aW9uLCBKVEEgdGFrZXMgY2Fy ZSBvZiB0aGF0LCBidXQgdGhlIHdob2xlIHByb2Nlc3MgaXMgYSBsb3QgbW9yZSBoZWF2eXdlaWdo dCBhbmQgdGFrZXMgbW9yZSByZXNvdXJjZXMgKHR3byBwb29sZWQgY29ubmVjdGlvbnMgaW5zdGVh ZCBvZiBvbmUpLCBwbHVzIHRoZSBjb29yZGluYXRpb24gYW1vbmcgdGhlbS4NCgk+PiAgIA0KCT4+ DQoJPg0KCT5UbyB0aGUgYmVzdCBvZiBteSBrbm93bGVkZ2UsIGFueSBkZWNlbnQgSlRBIGltcGxl bWVudGF0aW9uIHdpbGwgcmV0dXJuIHRoZSBzYW1lIENvbm5lY3Rpb24gaW5zdGFuY2UgaWYgYXNr ZWQgZm9yIGEgQ29ubmVjdGlvbiBmb3IgdGhlIHNhbWUgRGF0YVNvdXJjZSBhZ2FpbiB3aXRoaW4g YW4gYWN0aXZlIHRyYW5zYWN0aW9uLiBUaGlzIGlzIGV2ZW4gcmVjb21tZW5kZWQgYnkgdGhlIEpU QSBzcGVjLCB1bmRlciB0aGUgbmFtZSAibG9jYWwgdHJhbnNhY3Rpb24gb3B0aW1pemF0aW9uIiBJ SVJDLiBKVEEgdHJhbnNhY3Rpb24gbWFuYWdlcnMgd2lsbCB0eXBpY2FsbHkgbm90IHBlcmZvcm0g MlBDIGZvciBzdWNoIHNpbmdsZSBEYXRhU291cmNlIHRyYW5zYWN0aW9ucyBidXQganVzdCBmb3Ig YWN0dWFsIGRpc3RyaWJ1dGVkIG9uZXMuIEkgY29uc2lkZXIgaXQgc2FmZSB0byBhc3N1bWUgdGhh dCBhbGwgbWFqb3IgY29udGFpbmVycyBpbXBsZW1lbnQgaXQgdGhhdCB3YXkuDQoJPg0KCT5KdWVy Z2VuDQoJPg0KCT4NCgk+asO8cmdlbiBow7ZsbGVyIFt3ZXJrM0FUXSB3cm90ZToNCgk+DQoJPiAN Cgk+DQoJPj5Db2xpbiwNCgk+Pg0KCT4+WW91IG9idmlvdXNseSB3YW50IHRvIHBlcmZvcm0gcGxh aW4gSkRCQyBhY2Nlc3Mgd2l0aGluIHRoZSBzYW1lIHRyYW5zYWN0aW9uIGFzIHRoZSBIaWJlcm5h dGUgYWNjZXNzLiBUaGlzIGNhbiBiZSBhY2hpZXZlZCBlYXNpbHkgdmlhIEhpYmVybmF0ZVRyYW5z YWN0aW9uTWFuYWdlciBvciBKdGFUcmFuc2FjdGlvbk1hbmFnZXIsIHdpdGhvdXQgYW55IHNwZWNp ZmljIGdsdWluZy4NCgk+Pg0KCT4+SWYgeW91IGRlZmluZSBhIHJlc3BlY3RpdmUgSkRCQyBEYXRh U291cmNlIGluIHRoZSBhcHBsaWNhdGlvbiBjb250ZXh0LCBwb2ludGluZyB0byB0aGUgc2FtZSBv bmUgdGhhdCBIaWJlcm5hdGUgdXNlcyAoYmUgaXQgYSBsb2NhbCBvbmUgc3BlY2lmaWVkIG9uIExv Y2FsU2Vzc2lvbkZhY3RvcnlCZWFuIG9yIGEgc2hhcmVkIEpOREkgb25lKSwgeW91IGNhbiBtYWtl IEhpYmVybmF0ZVRyYW5zYWN0aW9uTWFuYWdlciBleHBvcnQgaXRzIHRyYW5zYWN0aW9ucyBmb3Ig dGhpcyBwYXJ0aWN1bGFyIERhdGFTb3VyY2UgYnkgcGFzc2luZyB0aGUgRGF0YVNvdXJjZSBhcyBi ZWFuIHJlZmVyZW5jZSBpbnRvIGl0cyAiZGF0YVNvdXJjZSIgcHJvcGVydHkuIEhpYmVybmF0ZVRy YW5zYWN0aW9uTWFuYWdlciB3aWxsIHNpbXBseSB0YWtlIHRoZSB2ZXJ5IEpEQkMgQ29ubmVjdGlv biB0aGF0IHRoZSBIaWJlcm5hdGUgU2Vzc2lvbiB1c2VzIGFuZCBiaW5kIGl0IHRvIHRoZSB0aHJl YWQgdmlhIERhdGFTb3VyY2VVdGlscyBmb3IgcGxhaW4gSkRCQyBhY2Nlc3Mgb24gdGhhdCBEYXRh U291cmNlLiBUaGUgbGF0dGVyIGRvZXMgbm90IGhhdmUgdG8gYmUgYXdhcmUgdGhhdCBpdCBpcyB3 b3JraW5nIHdpdGggYSBIaWJlcm5hdGUtcHJvdmlkZWQgQ29ubmVjdGlvbiENCgk+Pg0KCT4+V2l0 aCBKdGFUcmFuc2FjdGlvbk1hbmFnZXIsIGl0J3Mgc2ltaWxhcjogRGVmaW5lIHRoZSBzYW1lIEpO REkgRGF0YVNvdXJjZSB0aGF0IHRoZSBIaWJlcm5hdGUgU2Vzc2lvbkZhY3RvcnkgdXNlcyBmb3Ig dGhlIEpkYmNUZW1wbGF0ZSwgYW5kIEpUQSB3aWxsIGNhcmUgZm9yIHJldHVybmluZyB0aGUgc2Ft ZSBDb25uZWN0aW9uIHRvIGJvdGggdGhlIEhpYmVybmF0ZSBTZXNzaW9uIGFuZCB0aGUgSkRCQyBh Y2Nlc3MgY29kZSBpZiBpbiBhbiBhY3RpdmUgdHJhbnNhY3Rpb24uDQoJPj4NCgk+PlNvIGluIGFu eSBjYXNlLCB0aGlzICJzYW1lIERhdGFTb3VyY2UiIGFwcHJvYWNoIGlzIGFzIGVmZmljaWVudCBh cyBwYXNzaW5nIHRoZSBIaWJlcm5hdGUgU2Vzc2lvbidzIEpEQkMgQ29ubmVjdGlvbiBtYW51YWxs eSB0byBhIEpkYmNUZW1wbGF0ZSBpbnN0YW5jZSwgYXMgaXQgcmV1c2VzIHRoZSBzYW1lIENvbm5l Y3Rpb24gZm9yIGJvdGggdGhlIEhpYmVybmF0ZSBTZXNzaW9uIGFuZCB0aGUgSmRiY1RlbXBsYXRl IHdpdGhpbiBhIHRyYW5zYWN0aW9uLiBJIHN0cm9uZ2x5IHJlY29tbWVuZCBzdWNoIGEgc29sdXRp b24gb3ZlciBtYW51YWwgZ2x1aW5nLg0KCT4+DQoJPj5KdWVyZ2VuDQoJPj4NCgk+Pg0KCT4+DQoJ Pj4gICAgICAtLS0tLVVyc3Byw7xuZ2xpY2hlIE5hY2hyaWNodC0tLS0tDQoJPj4gICAgICBWb246 IENvbGluIFNhbXBhbGVhbnUgW21haWx0bzpjb2xpbm1sMUBleGlzLmNvbV0NCgk+PiAgICAgIEdl c2VuZGV0OiBNbyAyNS4wOC4yMDAzIDIzOjE0DQoJPj4gICAgICBBbjogasO8cmdlbiBow7ZsbGVy IFt3ZXJrM0FUXQ0KCT4+ICAgICAgQ2M6IHNwcmluZ2ZyYW1ld29yay1kZXZlbG9wZXJAbGlzdHMu c291cmNlZm9yZ2UubmV0DQoJPj4gICAgICBCZXRyZWZmOiBSZTogW1NwcmluZ2ZyYW1ld29yay1k ZXZlbG9wZXJdIFdoeSBkb2VzIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIGFsd2F5cyBzZXQg YXV0b0NvbW1pdD10cnVlPw0KCT4+ICAgIA0KCT4+ICAgIA0KCT4+DQoJPj4gICAgICBXL3JlZ2Fy ZHMgdG8gYXV0byBjb21taXQgaW4gdGhlIGRlZmF1bHQgY2FzZSAod2hlbiB0aGUgY2xhc3MgZ2V0 cyB0aGUNCgk+PiAgICAgIGNvbm5lY3Rpb24gaXRzZWxmKSwgSSB3b3VsZCBzYXksIGV4YWN0bHks IHRoZSBKREJDIHNwZWNzIHNwZWNpZmljYWxseQ0KCT4+ICAgICAgc2F5IHRoZSBnZXRDb25uZWN0 aW9uIGNhbGxlZCBvbiB0aGUgZGF0YXNvdXJjZSB3aWxsIHJldHVybiBhIGNvbm5lY3Rpb24NCgk+ PiAgICAgIHdpdGggYXV0b0NvbW1pdCBvbiBieSBkZWZhdWx0LiBTbyB3aHkgaXMgU2luZ2xlQ29u bmVjdGlvbkRhdGFTb3VyY2UgdGhlbg0KCT4+ICAgICAgZ29pbmcgYW5kIHNldHRpbmcgaXQgb24g YXMgd2VsbC4gR2l2ZW4gdGhhdCBTaW5nbGVDb25uZWN0aW9uRGF0YXNvdXJjZQ0KCT4+ICAgICAg ZG9lc24ndCBoYXZlIGFueSBjbHVlIGFib3V0IHRoZSBpbnRlbmRlZCB1c2Ugb2YgdGhlIGNvbm5l Y3Rpb24sIHRoZSBtb3N0DQoJPj4gICAgICBjb3JyZWN0IGJlaGF2aW91ciBpcyBwcm9iYWJseSB0 byBub3QgaGF2ZSBpdCBjYWxsIHNldEF1dG9Db21taXQgd2l0aA0KCT4+ICAgICAgZWl0aGVyIHN0 YXRlLCBieSBkZWZhdWx0LCB3aGljaCB3b3VsZCBtaXJyb3Igbm9ybWFsDQoJPj4gICAgICBkYXRh c291cmNlL2Nvbm5lY3Rpb24gdXNhZ2UsIGFuZCBhbHNvIGFsbG93IGEgbWVjaGFuaXNtIHRvIHNw ZWNpZnkgdGhhdA0KCT4+ICAgICAgaXQgc2hvdWxkIGJlIGNhbGxlZCBvbmUgd2F5IG9yIGFub3Ro ZXIuIEhvd2V2ZXIsIHRoaXMgbWF5IGJlIG1vcmUgd29yaw0KCT4+ICAgICAgdGhhbiBpcyB3b3J0 aCBpdCwgYW5kIGEgZGVmYXVsdCBjYWxsIHdpdGggdGhlIG9wdGlvbiB0byBvbiwgYWxvbmcgd2l0 aCBhDQoJPj4gICAgICBtZWNoYW5pc20gKGFub3RoZXIgY29uc3RydWN0b3Igd2l0aCBhIHZhbHVl IGZvciB0aGUgY2FsbCkgdG8gb3ZlcnJpZGUNCgk+PiAgICAgIGl0LCB3b3VsZCBiZSBmaW5lLiBT byB0byBiZSBjbGVhciwgSSBkbyB0aGluayBldmVuIHdoZW4NCgk+PiAgICAgIFNpbmdsZUNvbm5l Y3Rpb25EYXRhU291cmNlIGdldHMgdGhlIGNvbm5lY3Rpb24gdGhlcmUgaXMgYSBuZWVkIGZvciBh bg0KCT4+ICAgICAgb3ZlcnJpZGUuDQoJPj4gICAgDQoJPj4gICAgICBBcyBmb3IgbXkgdXNlIGNh c2UsIEkgZG9uJ3QgdGhpbmsgSSB3YXMgY2xlYXIgZW5vdWdoLiAgSSBoYXZlIHNvbWUgY29kZQ0K CT4+ICAgICAgaW4gYSBIaWJlcm5hdGUgc3BlY2lmaWMgREFPL01hcHBlciBvYmplY3QuIEkgYW0g YWxyZWFkeSBleGVjdXRpbmcgaW5zaWRlDQoJPj4gICAgICBhIHRyYW5zYWN0aW9uIGludHJvZHVj ZWQgdmlhIFNwcmluZydzIEFPUCBpbnRlcmNlcHRvci4gU28gSSBkbyBoYXZlIGENCgk+PiAgICAg IFNlc3Npb25GYWN0b3J5LCBldGMuIGJvdW5kIHRvIHRoZSB0aHJlYWQuIE5vdyBpbnNpZGUgYSBt ZXRob2QgaW4gdGhpcw0KCT4+ICAgICAgbWFwcGVyIEkgbmVlZCB0byBkbyBhbiBvcGVyYXRpb24g b24gYSBCTE9CL0NMT0IsIHdoZXJlIHRoZXJlIGFyZSBhDQoJPj4gICAgICBudW1iZXIgb2YgZGIg cGxhdGZvcm0gc3BlY2lmaWMgaXNzdWVzLCBhbmQgSGliZXJuYXRlJ3Mgc3VwcG9ydCBvZg0KCT4+ ICAgICAgQkxPQnMvQ0xPQnMgaXMgbm90IGdvb2QgZW5vdWdoLiBHaXZlbiB0aGF0IEkgaGF2ZSBh IEhpYmVybmF0ZSBTZXNzaW9uDQoJPj4gICAgICB3aGljaCBhbHJlYWR5IGhhcyBhIGNvbm5lY3Rp b24gYXZhaWxhYmxlLCB1c2luZyBpdCBpcyB0aGUgYmVzdCBtZWNoYW5pc20NCgk+PiAgICAgIChh cyBvcHBvc2VkIHRvIHRyeWluZyB0byBnZXQgYSByZWFsIERhdGFTb3VyY2UgaW4gU3ByaW5nJ3Mg Y29udGV4dCB0bw0KCT4+ICAgICAgdXNlKS4gTm93IEkgYW0gdXNpbmcgSkRCQ1RlbXBsYXRlIGFu ZCBKREJDSGVscGVyIGFzIGNvbnZlbmllbmNlIGNsYXNzZXMsDQoJPj4gICAgICB0byB3cmFwIEpE QkMgZXhjZXB0aW9ucywgYW5kIGZvciB0aGUgbWV0aG9kcyB0aGV5IHByb3ZpZGUuIE5vdyBJIGNv dWxkIGNhbGwNCgk+PiAgICAgICAgRGF0YVNvdXJjZVV0aWxzLmdldFRocmVhZE9iamVjdE1hbmFn ZXIoKS5iaW5kVGhyZWFkT2JqZWN0KC4uLikNCgk+PiAgICAgIHRvIGJpbmQgdGhlIFNpbmdsZUNv bm5lY3Rpb25EYXRhc291cmNlIHRvIHRoZSB0aHJlYWQsIGJlZm9yZSB1c2luZyB0aGUNCgk+PiAg ICAgIEpEQkNUZW1wbGF0ZSwgYnV0IEknbSBub3Qgc3VyZSB0aGF0J3MgYnV5aW5nIG1lIG11Y2gg b3ZlciB0aGUgY2FzZSBvZg0KCT4+ICAgICAgbm90IGJpbmRpbmcgaXQuIEluIGVpdGhlciBjYXNl LCBKREJDVGVtcGxhdGUgaXMgc2ltcGx5IGdvaW5nIHRvIGVuZCB1cA0KCT4+ICAgICAgZ2V0dGlu ZyB0aGUgc2FtZSBDb25uZWN0aW9uLiBCZWNhdXNlIEkgYW0gdXNpbmcgdGhlDQoJPj4gICAgICBT aW5nbGVDb25uZWN0aW9uRGF0YXNvdXJjZSwgaXQncyBub3QgbGlrZSBpbiB0aGlzIGNhc2UgdGhl cmUgaXMgYSByZWFsDQoJPj4gICAgICBEYXRhU291cmNlIG9iamVjdCwgYW5kIHlvdSBvbmx5IHdh bnQgdG8gY2FsbCBnZXRDb25uZWN0aW9uIG9uIGl0IG9uY2UuLi4NCgk+PiAgICANCgk+PiAgICAg IEhvcGVmdWxseSBteSBleGFwbGFuYXRpb24gaXMgY2xlYXIgbm93Li4uDQoJPj4gICAgDQoJPj4g ICAgDQoJPj4gICAgICBqw7xyZ2VuIGjDtmxsZXIgW3dlcmszQVRdIHdyb3RlOg0KCT4+ICAgIA0K CT4+ICAgICAgPkkgYWdyZWUgdGhhdCBpbiBjYXNlIG9mIGFuIGV4aXN0aW5nIGNvbm5lY3Rpb24s IFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIHNob3VsZCBub3Qgb3ZlcnJpZGUgdGhlIGNvbW1p dCBtb2RlLiBGb3IgdGhlIGRlZmF1bHQgY2FzZSwgSSBjb25zaWRlciBhdXRvIGNvbW1pdCBtb2Rl IGFwcHJvcHJpYXRlIHRob3VnaC4gQW55IEoyRUUgRGF0YVNvdXJjZSB3aWxsIHJldHVybiBhbiBh dXRvIGNvbW1pdCBjb25uZWN0aW9uIG91dHNpZGUgYSB0cmFuc2FjdGlvbiwgc28gd2h5IHNob3Vs ZG4ndCBTaW5nbGVDb25uZWN0aW9uRGF0YVNvdXJjZSBkbyB0b28/DQoJPj4gICAgICA+DQoJPj4g ICAgICA+QlRXLCB3aGF0IHlvdSBhcmUgdHJ5aW5nIHRvIGRvIHNlZW1zIGEgYml0IGF3a3dhcmQu IFdoeSBtYW51YWxseSBmZWVkIHRoZSBDb25uZWN0aW9uIG9mIGEgSGliZXJuYXRlIFNlc3Npb24g dmlhIFNpbmdsZUNvbm5lY3Rpb25EYXRhU291cmNlIHRvIEpkYmNUZW1wbGF0ZT8gSmRiY1RlbXBs YXRlIGlzIHN1cHBvc2VkIHRvIGJlIGEgdGhyZWFkc2FmZSwgcmV1c2FibGUgb2JqZWN0LCBmZXRj aGluZyBjb25uZWN0aW9ucyBvbiBkZW1hbmQuIFdvdWxkbid0IGl0IGJlIGVhc2llciB0byB1c2Ug U3ByaW5nJ3MgdGhyZWFkLWJpbmRpbmcgbWVjaGFuaXNtIChEYXRhU291cmNlVXRpbHMuZ2V0VGhy ZWFkT2JqZWN0TWFuYWdlcikgdG8gbWFrZSBKZGJjVGVtcGxhdGUgdXNlIGEgc3BlY2lmaWMgY29u bmVjdGlvbiwgYmUgaXQgaW1wbGljaXRseSB2aWEgSGliZXJuYXRlVHJhbnNhY3Rpb25NYW5hZ2Vy IG9yIGV4cGxpY2l0bHkgaW4gc29tZSBjdXN0b20gd2F5Pw0KCT4+ICAgICAgPg0KCT4+ICAgICAg Pkp1ZXJnZW4NCgk+PiAgICAgID4NCgk+PiAgICAgID4NCgk+PiAgICAgID4NCgk+PiAgICAgID4g ICAgICAgLS0tLS1VcnNwcsO8bmdsaWNoZSBOYWNocmljaHQtLS0tLQ0KCT4+ICAgICAgPiAgICAg ICBWb246IENvbGluIFNhbXBhbGVhbnUgW21haWx0bzpjb2xpbm1sMUBleGlzLmNvbV0NCgk+PiAg ICAgID4gICAgICAgR2VzZW5kZXQ6IE1vIDI1LjA4LjIwMDMgMjA6MDINCgk+PiAgICAgID4gICAg ICAgQW46IHNwcmluZ2ZyYW1ld29yay1kZXZlbG9wZXJAbGlzdHMuc291cmNlZm9yZ2UubmV0DQoJ Pj4gICAgICA+ICAgICAgIENjOg0KCT4+ICAgICAgPiAgICAgICBCZXRyZWZmOiBbU3ByaW5nZnJh bWV3b3JrLWRldmVsb3Blcl0gV2h5IGRvZXMgU2luZ2xlQ29ubmVjdGlvbkRhdGFTb3VyY2UgYWx3 YXlzIHNldCBhdXRvQ29tbWl0PXRydWU/DQoJPj4gICAgICA+ICAgIA0KCT4+ICAgICAgPiAgICAN Cgk+PiAgICAgID4NCgk+PiAgICAgID4gICAgICAgSSB3YW50IHRvIHVzZSBTaW5nbGVDb25uZWN0 aW9uRGF0YVNvdXJjZSB3aXRoIEhpYmVybmF0ZSwgc28gSSBjYW4gd3JhcCBhDQoJPj4gICAgICA+ ICAgICAgIGNvbm5lY3Rpb24gSSBnZXQgZnJvbSBhIEhpYmVybmF0ZSBTZXNzaW9uLCBhbmQgZmVl ZCBpdCBhcyBhIERhdGFTb3VyY2UNCgk+PiAgICAgID4gICAgICAgdG8gSkRCQ1RlbXBsYXRlL0pE QkNIZWxwZXIuDQoJPj4gICAgICA+ICAgIA0KCT4+ICAgICAgPiAgICAgICBIb3dldmVyLCByaWdo dCBub3cgSSd2ZSBoYWQgdG8gbWFrZSBteSBvd24gdmFyaWFudCBzaW5jZSB0aGUgY3VycmVudA0K CT4+ICAgICAgPiAgICAgICBjb2RlIGFsd2F5cyBjYWxscw0KCT4+ICAgICAgPiAgICAgICAgIHNv dXJjZS5zZXRBdXRvQ29tbWl0KHRydWUpOw0KCT4+ICAgICAgPiAgICAgICBpbiB0aGUgaW5pdCgp IG1ldGhvZC4gIFRoaXMgc2VlbXMgdmVyeSBhcmJpdHJhcnkgdG8gbWUuIEF0IGxlYXN0IGluIHRo ZQ0KCT4+ICAgICAgPiAgICAgICBjYXNlIHdoZW4gdGhlIGNsYXNzIGlzIGdpdmVuIGFuIGV4aXN0 aW5nIGNvbm5lY3Rpb24sIGl0IHNob3VsZCBqdXN0DQoJPj4gICAgICA+ICAgICAgIGFzc3VtZSB0 aGUgY29tbWl0IG9wdGlvbiBoYXMgYmVlbiBzZXQgYXBwcm9wcmlhdGVseSBvbiB0aGUgY29ubmVj dGlvbi4NCgk+PiAgICAgID4gICAgDQoJPj4gICAgICA+ICAgICAgIEV2ZW4gaW4gdGhlIGNhc2Ug d2hlbiB0aGUgY2xhc3MgaXMgb3BlbmluZyB0aGUgY29ubmVjdGlvbiBpdHNlbGYgZnJvbSBhbg0K CT4+ICAgICAgPiAgICAgICBleGlzdGluZyBEYXRhU291cmNlLCB0aGVyZSBuZWVkcyB0byBiZSBh biBvcHRpb24gdG8gc2V0IGF1dG9Db21taXQNCgk+PiAgICAgID4gICAgICAgZWl0aGVyIHdheS4N Cgk+PiAgICAgID4gICAgDQoJPj4gICAgICA+ICAgICAgIFJlZ2FyZHMsDQoJPj4gICANCgk+Pg0K CQ0KCQ0KCQ0KCQ0KDQo= |
|
From: Colin S. <col...@ex...> - 2003-08-25 22:29:59
|
I agree that if I used HibernateTransactionManager, the impact is essentially the same, since the HibernateTransactionManager is going to directly bind the DataSource to the thread, and when a connection is needed the spring classes will see it there and return the existing thread bound connection instead of ever calling getConnection on it. My feeling however is that with JTATransactionManager things are much worse if I don't bind the fake datasource myself, or feed it to JDBCTemplate. Since in this case the DataSource is not already bound to the thread, in this case, my JDBC code ends up calling getConnection on the real DataSource (from JNDI). Then that datasource ends up allocating a new connection from its pool, which is returned to me. There is no issue in terms of working together with the existing connection, JTA takes care of that, but the whole process is a lot more heavyweight and takes more resources (two pooled connections instead of one), plus the coordination among them. Is this not an accurate description of the situation? Regards, Colin jürgen höller [werk3AT] wrote: >Colin, > >You obviously want to perform plain JDBC access within the same transaction as the Hibernate access. This can be achieved easily via HibernateTransactionManager or JtaTransactionManager, without any specific gluing. > >If you define a respective JDBC DataSource in the application context, pointing to the same one that Hibernate uses (be it a local one specified on LocalSessionFactoryBean or a shared JNDI one), you can make HibernateTransactionManager export its transactions for this particular DataSource by passing the DataSource as bean reference into its "dataSource" property. HibernateTransactionManager will simply take the very JDBC Connection that the Hibernate Session uses and bind it to the thread via DataSourceUtils for plain JDBC access on that DataSource. The latter does not have to be aware that it is working with a Hibernate-provided Connection! > >With JtaTransactionManager, it's similar: Define the same JNDI DataSource that the Hibernate SessionFactory uses for the JdbcTemplate, and JTA will care for returning the same Connection to both the Hibernate Session and the JDBC access code if in an active transaction. > >So in any case, this "same DataSource" approach is as efficient as passing the Hibernate Session's JDBC Connection manually to a JdbcTemplate instance, as it reuses the same Connection for both the Hibernate Session and the JdbcTemplate within a transaction. I strongly recommend such a solution over manual gluing. > >Juergen > > > > -----Ursprüngliche Nachricht----- > Von: Colin Sampaleanu [mailto:col...@ex...] > Gesendet: Mo 25.08.2003 23:14 > An: jürgen höller [werk3AT] > Cc: spr...@li... > Betreff: Re: [Springframework-developer] Why does SingleConnectionDataSource always set autoCommit=true? > > > > W/regards to auto commit in the default case (when the class gets the > connection itself), I would say, exactly, the JDBC specs specifically > say the getConnection called on the datasource will return a connection > with autoCommit on by default. So why is SingleConnectionDataSource then > going and setting it on as well. Given that SingleConnectionDatasource > doesn't have any clue about the intended use of the connection, the most > correct behaviour is probably to not have it call setAutoCommit with > either state, by default, which would mirror normal > datasource/connection usage, and also allow a mechanism to specify that > it should be called one way or another. However, this may be more work > than is worth it, and a default call with the option to on, along with a > mechanism (another constructor with a value for the call) to override > it, would be fine. So to be clear, I do think even when > SingleConnectionDataSource gets the connection there is a need for an > override. > > As for my use case, I don't think I was clear enough. I have some code > in a Hibernate specific DAO/Mapper object. I am already executing inside > a transaction introduced via Spring's AOP interceptor. So I do have a > SessionFactory, etc. bound to the thread. Now inside a method in this > mapper I need to do an operation on a BLOB/CLOB, where there are a > number of db platform specific issues, and Hibernate's support of > BLOBs/CLOBs is not good enough. Given that I have a Hibernate Session > which already has a connection available, using it is the best mechanism > (as opposed to trying to get a real DataSource in Spring's context to > use). Now I am using JDBCTemplate and JDBCHelper as convenience classes, > to wrap JDBC exceptions, and for the methods they provide. Now I could call > DataSourceUtils.getThreadObjectManager().bindThreadObject(...) > to bind the SingleConnectionDatasource to the thread, before using the > JDBCTemplate, but I'm not sure that's buying me much over the case of > not binding it. In either case, JDBCTemplate is simply going to end up > getting the same Connection. Because I am using the > SingleConnectionDatasource, it's not like in this case there is a real > DataSource object, and you only want to call getConnection on it once... > > Hopefully my exaplanation is clear now... > > > jürgen höller [werk3AT] wrote: > > >I agree that in case of an existing connection, SingleConnectionDataSource should not override the commit mode. For the default case, I consider auto commit mode appropriate though. Any J2EE DataSource will return an auto commit connection outside a transaction, so why shouldn't SingleConnectionDataSource do too? > > > >BTW, what you are trying to do seems a bit awkward. Why manually feed the Connection of a Hibernate Session via SingleConnectionDataSource to JdbcTemplate? JdbcTemplate is supposed to be a threadsafe, reusable object, fetching connections on demand. Wouldn't it be easier to use Spring's thread-binding mechanism (DataSourceUtils.getThreadObjectManager) to make JdbcTemplate use a specific connection, be it implicitly via HibernateTransactionManager or explicitly in some custom way? > > > >Juergen > > > > > > > > -----Ursprüngliche Nachricht----- > > Von: Colin Sampaleanu [mailto:col...@ex...] > > Gesendet: Mo 25.08.2003 20:02 > > An: spr...@li... > > Cc: > > Betreff: [Springframework-developer] Why does SingleConnectionDataSource always set autoCommit=true? > > > > > > > > I want to use SingleConnectionDataSource with Hibernate, so I can wrap a > > connection I get from a Hibernate Session, and feed it as a DataSource > > to JDBCTemplate/JDBCHelper. > > > > However, right now I've had to make my own variant since the current > > code always calls > > source.setAutoCommit(true); > > in the init() method. This seems very arbitrary to me. At least in the > > case when the class is given an existing connection, it should just > > assume the commit option has been set appropriately on the connection. > > > > Even in the case when the class is opening the connection itself from an > > existing DataSource, there needs to be an option to set autoCommit > > either way. > > > > Regards, > > Colin > > > > > > > > > > |
