AbstractDetectingUrlLermapping Register Handler melalui pemindaian, dan didistribusikan oleh GetHandlerinternal dari Abstracturlhandlermapping saat menerima permintaan.
Ada 5 subclass dan satu kelas abstrak.
Mirip dengan SimpleUrlHandermapping, ini diinisialisasi dengan menimpa initApplicationContext dan kemudian memanggil detecthandlers.
Detecthandlers memindai objek aplikasi melalui beanfactoryutils, dan kemudian memesan penentu untuk for subclass untuk menghasilkan URL yang sesuai sesuai dengan pawang.
Registershandler terdaftar masih disediakan oleh AbstracturlHandlermapping.
// AbstractDetectingUrlHandLermapping/*** memanggil metode {@link #detecthandlers ()} selain*inisialisasi superclass.*/@overridepublic void initApplicationContext () lemparan applicationContextException {super.initapplicationContext (); detecThand {super.initaplicationContext (); Ini juga disebut InitiPlicationContext Initialization Interceptor dari Abstracthandlermapping.
Protagonis muncul, detecthandlers, pindai penangan
// AbstractDetectingUrlHandLermapping/*** Daftarkan semua penangan yang ditemukan di ApplicationContext saat ini.* <p> Penentuan URL aktual untuk pawang terserah pada Implementasi Beton* {@Link #DetermineUrlsFFORHandler (String)}. A bean for* which no such URLs could be determined is simply not considered a handler.* @throws org.springframework.beans.BeansException if the handler couldn't be registered* @see #determineUrlsForHandler(String)*/protected void detectHandlers() throws BeansException {if (logger.isDebugEnabled()) {logger.debug ("Mencari pemetaan URL dalam konteks aplikasi:" + getApplicationContext ());} string [] beanNames = (this.detecthandlersinancestorcontexts? beanfactoryutils.beannamesypleIncesTors (getapplicationContext (), context (), context.), getapplication : getApplicationContext (). GetBeanNamesFortype (Object.class)); // Ambil nama kacang apa pun yang dapat kita tentukan URLS for.for (string beanname: beannames) {string [] URLS = DESTIPSFORHANDLER (beanname); if (!ObjectUtils.isEmpty(urls)) {// URL paths found: Let's consider it a handler.registerHandler(urls, beanName);}else {if (logger.isDebugEnabled()) {logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");}}}} Metode template yang disediakan di sini didefinisikan sebagai berikut:
/*** Tentukan URL untuk kacang pawang yang diberikan.* @Param beanname nama kandidat kacang* @return URL yang ditentukan untuk kacang,* atau {@code null} atau array kosong jika tidak ada*/string abstrak yang dilindungi [] DetectForForHandler (string beanName); Mari kita lihat implementasi metode template di beannameurlhandlermapping dan abstractControllerUrlHandlermapping. BeanNameUrlHandlermapping sangat sederhana, sehingga mengimplementasikan DefitedUrlsForHandler. The alias in it should be configured in the configuration file through beanName.// BeanNameUrlHandlerMapping/*** Checks name and aliases of the given bean for URLs, starting with "/".*/@Overrideprotected String[] determineUrlsForHandler(String beanName) {List<String> urls = new ArrayList<String>();if (beanname.startswith ("/")) {urls.add (beanname);} string [] aliases = getApplicationContext (). getaliases (beanname); untuk (string alias: alias) {if (alias.startswith ("/")) {urls.add (alias);}} return stringutils.tostringarray (urls);} Mari kita lihat implementasi di AbstractControllerurlHandlermapping
ISeLigibleFormapping menentukan apakah pengontrol dikecualikan (dikecualikan melalui paket paket atau kelas kelas).
BuildurlsForHandler mengimplementasikan aturan pembuatan URL spesifik dari subkelas
isControllerType menentukan apakah subkelas pengontrol
Metode Template BuildurlsForHandler untuk URL produksi subkelas.
// AbstractControllerUrlHandLermapping/*** Delegasi Implementasi ini ke {@link #buildurlsForHandler},*asalkan {@link #iseligibleFormapping} returns {@code true}.* getApplicationContext().getType(beanName);if (isEligibleForMapping(beanName, beanClass)) {return buildUrlsForHandler(beanName, beanClass);}else {return null;}} // AbstractControllerUrlHandlerMapping/**Just determine whether the controller is excluded from this mapping.* @param beanName the name of the controller bean* @param beanClass the concrete class of the controller bean* @return whether the specified class is excluded* @see #setExcludedPackages* @see #setExcludedClasses*/protected boolean isEligibleForMapping(String beanName, Class beanClass) {if (beanClass == null) {if (Logger.isdebugeNabled ()) {logger.debug ("Kecualikan kacang pengontrol '" + beanname + "' dari pemetaan nama kelas" + "karena tipe kacang tidak dapat ditentukan");} return false;} if (this.excludedclasses.contains (beanclass) {ife -excludedclass. {Logger.Debug ("Kecualikan Controller Bean '" + BeanName + "' dari Class Name Mapping" + "karena kelas kacangnya secara eksplisit dikecualikan:" + beansclass.getName ());} return false;} string string: beansclass.getname (); untuk (string packagen packagen: therexage = therexclass.getname (); for (string packagen packagen: thingpack: therexage. (beansclassname.startswith (packageName)) {if (logger.isdebugeNabled ()) {logger.debug ("Kecualikan controller bean '" + beanname + "' dari class name pemetaan" + "karena kelas bean) (kembali) ew -name; isControllerType (beansclass);} // abstractControllerUrlHandlermapping/*** Tentukan apakah kelas kacang yang diberikan menunjukkan tipe pengontrol* yang didukung oleh strategi pemetaan ini.* @param beanClass {retrippedypedypedypedyped (class beansclass) {return ini. ControllerTypePredicate provides 2 APIs to determine whether it is a subclass of Controller or a subclass of MultiActionController./*** Internal helper class that identifies controller types.** @author Juergen Hoeller* @since ..*/class ControllerTypePredicate {public boolean isControllerType(Class beanClass) {return Controller.class.isassignableFrom (beanClass);} public boolean isMultiactionControllerType (class beansclass) {return multiactioncontroller.class.isassignableFrom (beansclass);}} Cadangan metode template untuk menghasilkan URL
// AbstractControllerUrlHandlermapping/*** Metode templat abstrak yang akan diimplementasikan oleh subkelas.* @Param Beanname Nama kacang* @param beanclass jenis kacang* @return yang ditentukan untuk kacang*/string abstrak yang dilindungi [] buildurlsforhandler (string beingname, beingname, string beingname, string beingname, being name, beingname, string beingname, beingname, string beingname, beingeName, string beyname) (string being name);
Mari kita lihat dua implementasi AbstractControllerUrlHandlermapping ControllerbeanNameUrlHandLermapping dan ControllerClassNameUrlHandLermapping.
Bahkan, keduanya sangat sederhana. Salah satunya adalah menghasilkan URL berdasarkan Beanname, dan yang lainnya adalah menghasilkan URL berdasarkan ClassName.
// ControllerBeanNameUrlHandlerMapping@Overrideprotected String[] buildUrlsForHandler(String beanName, Class beanClass) {List<String> urls = new ArrayList<String>();urls.add(generatePathMapping(beanName));String[] aliases = getApplicationContext().getAliases(beanName);// Also get the Alias untuk (string alias: alias) {urls.add (generatePathMapping (alias));} return stringutils.tostringarray (urls);} // controllerbeanNameUrlandlermapping/** Tambahkan string '/' jika diperlukan dan menambahkan Url Suffix ke nama tersebut. (beanname.startswith ("/")? beanname: "/" + beanname); stringbuilder path = stringBuilder baru (); if (! name.startswith (this.urlprefix)) {path.append (this.urlprefix);} path.urlpend (name); if name); ife. {path.append (this.urlsuffix);} return path.toString ();} // controllerclassnameurlhandlermapping Langsung mendelegasikan untuk menghasilkan implementasi
@OverrideProtected String [] buildUrlsForHandler (string beanname, class beanClass) {return generatePathMappings (beanClass);} // controllerclassnameurlhandlermapping Dapatkan awalan jalur melalui buildpathpathprefix
Dapatkan ClassName melalui Classutils, seperti BookController (tanpa nama paket), dan gunakan proxy CGLIB untuk menyelesaikan masalah bersama.
Konversi className menurut apakah kasus ini sensitif (cases default sensitif = false;)
IsMultiactionControllerType menentukan apakah pengontrol adalah subkelas dari multi -actickontroller, yaitu, apakah pengontrol berisi beberapa penangan.
/*** Hasilkan jalur URL aktual untuk kelas pengontrol yang diberikan.* <p> Subkelas dapat memilih untuk menyesuaikan jalur yang dihasilkan* dengan mengesampingkan metode ini.* @Param beanClass kelas kacang pengontrol untuk menghasilkan pemetaan* @return Path URL untuk controller yang diberikan*/string yang dilindungi [] generpathmin genermappatpatping (genermpathmin (PATPATHMPLAS (GenerMappathmin (PathMapping (GenerMappatpatpatpatpatpatpatpatping (GenerMappatpatpatpatpatpatpatpatpatpatpatpatpatpatpatpatpatpatpatpy (GenerMappathm) buildPathPrefix (beansclass); string className = classutils.getshortname (beansclass); string path = (classname.endswith (controller_suffix)? className.substring (, className.LastIndexOf (controller_suffix)): className); if className.lastIndexOf (controller_Suffix)): className); if classname.lastIndExOf (controller_suffix)): className); if classname.lastindexOf (controller_suffix)): className); if className.lase (controller_suffix)): className () (if className (controllerer () (classname (); {pathMapping.append(path.substring(, ).toLowerCase()).append(path.substring());}else {pathMapping.append(path.toLowerCase());}}if (isMultiActionControllerType(beanClass)) {return new String[] {pathMapping.toString(), pathMapping.toString() + "/*"};} else {return new string [] {PathMapping.toString () + "*"};}} // controllerClassNameUrlHandlermapping/*** Bangun awalan jalur untuk kelas pengontrol yang diberikan. StringBuilder buildPathPrefix (class beansclass) {stringBuilder pathmapping = new stringBuilder (); if (this.pathphrefix! = Null) {pathmapping.append (this.pathpathprefix); pathmapping.append ("/");} else {pathmapping.applepend); packageName = classutils.getpackagename (beansclass); if (packageName.startswith (this.basepackage)) {string subpackage = packageName.substring (this.basepackage.length ()). ganti ('.', '/' /);pathmapping.pathris.pathris.pathris.cends. subpackage: subpackage.tolowercase ()); pathmapping.append ("/");}} return pathmapping;} // abstractControllerUrlHandlermapping Predicate.ismultiactionControllerType Implementasi spesifik Lihat ControlTypePedicate di atas
/*** Tentukan apakah kelas kacang yang diberikan menunjukkan tipe pengontrol* yang mengirim ke beberapa metode tindakan.* @Param beanClass kelas untuk introspeksi*/lindung boolean isMultiactionControllerType (class beanClass) {return this.predicate.ismultiactionControllerType (beanClass);};Di atas adalah pengetahuan yang relevan tentang inisialisasi interpretasi kode sumber SpringMVC dari Handlermapping - AbstractDettectingUrlHandlermapping seri yang diperkenalkan oleh editor kepada Anda. Saya harap ini akan membantu semua orang!