IoC स्टार्टर के साथ वेब ऐप। Ioc संदर्भ, ioc वेब और ioc orm का उपयोग करके मूल क्वेरी मैपिंग

परिचय

पहली रिलीज के बाद से, बहुत समय बीत चुका है ( पिछले लेख के लिए लिंक )। क्या बदल गया है?

• एक पूरे के रूप में प्रणाली की बेहतर स्थिरता;
• कार्यान्वित आलसी घटक लोड हो रहा है;
• अंतर्निहित बुनियादी श्रोता प्रणाली
• पहलू-उन्मुख प्रोग्रामिंग के लिए अंतर्निहित समर्थन (समस्याओं को हल करने में मध्यम कठिनाई के लिए, अन्यथा मैं आपको बाकी के लिए एस्पेक्टज लाइब्रेरी का उपयोग करने की सलाह देता हूं)
• नया रिक्फ़र्वेटरी बूट लोडर
• EhCache, अमरूद पर आधारित कैश के साथ एकीकृत कार्य
• धाराओं के साथ काम एकीकृत है (@SimpleTask एनोटेशन और पूल के साथ सीधे काम के माध्यम से दोनों आरंभीकरण)

** मॉड्यूल

• डेटाबेस के साथ काम करने के लिए मॉड्यूल (जेपीए, लेनदेन के लिए समर्थन के साथ हल्के ओआरएम, नो-एसक्यूएल ड्राइवर - ओरिएंट, क्रूड विधियों, रिपॉजिटरी सिस्टम और रिपॉजिटरी क्लास के फ़ंक्शन से ऑटो-जनरेट किए गए प्रश्न)
• वेब थूथन मॉड्यूल (लिंक मानचित्रण एनोटेशन के माध्यम से, कस्टम उत्पादकों / उपभोगताओं के लिए समर्थन, वेलकम टेम्प्लेट रेंडरिंग पेज, बेसिक सिक्योरिटी रिक्वेस्ट, सेशंस, कुकीज, एसएसएल) नेट्टी 4.1.30 पर आधारित।

ढांचा संरचना

"बेशक, यह सब अच्छा है," आप कहते हैं, "लेकिन वास्तव में यह सब काम करता है?"
"हाँ, यह काम करता है। मैं कटौती के लिए कहता हूं।"

उदाहरण कार्यान्वयन प्रक्रिया

उदाहरण को लागू करने के लिए, मैं मावेन 3 और इंटेलीज आइडिया 2018.2 का उपयोग करूंगा।

1) निर्भरता कनेक्ट करें:

<?xml version="1.0" encoding="UTF-8"?> <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <artifactId>example-webapp</artifactId> <groupId>org.ioc</groupId> <packaging>jar</packaging> <version>0.0.1</version> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.0</version> <configuration> <.source>1.8</source> <target>1.8</target> </configuration> <executions> <execution> <id>default-testCompile</id> <phase>test-compile</phase> <goals> <goal>testCompile</goal> </goals> </execution> </executions> </plugin> </plugins> </build> <dependencies> <dependency> <groupId>org.ioc</groupId> <artifactId>context-factory</artifactId> <version>2.2.4.STABLE</version> </dependency> <dependency> <groupId>org.ioc</groupId> <artifactId>orm-factory</artifactId> <version>2.2.4.STABLE</version> </dependency> <dependency> <groupId>org.ioc</groupId> <artifactId>web-factory</artifactId> <version>2.2.4.STABLE</version> </dependency> </dependencies> <repositories> <repository> <id>context</id> <url>https://raw.github.com/GenCloud/ioc_container/context</url> </repository> <repository> <id>cache</id> <url>https://raw.github.com/GenCloud/ioc_container/cache</url> </repository> <repository> <id>threading</id> <url>https://raw.github.com/GenCloud/ioc_container/threading</url> </repository> <repository> <id>orm</id> <url>https://raw.github.com/GenCloud/ioc_container/orm</url> </repository> <repository> <id>web</id> <url>https://raw.github.com/GenCloud/ioc_container/web</url> </repository> </repositories> </project> 

** वह अभी तक केंद्रीय, अफसोस के लिए स्थानांतरित नहीं हुआ है।

परियोजना संरचना:

मानक MVC पैटर्न, है ना?

आवेदन के लिए एक प्रवेश बिंदु बनाएँ:

 package org.examples.webapp; import org.ioc.annotations.context.ScanPackage; import org.ioc.annotations.modules.CacheModule; import org.ioc.annotations.modules.DatabaseModule; import org.ioc.annotations.modules.ThreadingModule; import org.ioc.annotations.modules.WebModule; import org.ioc.context.starter.IoCStarter; @WebModule @CacheModule @ThreadingModule @DatabaseModule @ScanPackage(packages = {"org.examples.webapp"}) public class AppMain { public static void main(String[] args) { IoCStarter.start(AppMain.class); } } 

** स्पष्टीकरण:
एनोटेशन @ScanPackages - घटकों की पहचान करने के लिए प्रासंगिक पैकेज को परिभाषित करता है (आम लोगों में - "डिब्बे")।
एनोटेशन @WebModule - वेब फैक्ट्री को जोड़ने और आरंभ करने का कार्य करता है।
एनोटेशन @CacheModule - ORM के सही संचालन के लिए (भविष्य के संस्करणों में, एनोटेशन की आवश्यकता नहीं होगी), कैश फैक्ट्री को जोड़ने और आरंभ करने के लिए उपयोग किया जाता है।
एनोटेशन @ThreadingModule - का उपयोग किसी थ्रेड फैक्ट्री को जोड़ने और आरंभ करने के लिए किया जाता है, इसका उपयोग वेब फैक्ट्री के सही संचालन के लिए किया जाता है (भविष्य के संस्करणों में, एनोटेशन की आवश्यकता नहीं होगी)।
एनोटेशन @DatabaseModule - ORM फैक्ट्री को जोड़ने और आरंभ करने के लिए प्रयुक्त ।
सभी कारखानों में डिफ़ॉल्ट विन्यासकर्ता होते हैं, जिन्हें आप कारखानों द्वारा उपयोग की जाने वाली सेटिंग्स के कार्यों को फिर से परिभाषित करने के साथ बदल सकते हैं (प्रत्येक मॉड्यूल एनोटेशन में वर्ग विन्यासकर्ता को फिर से परिभाषित किया जाता है - कक्षा <?> AutoConfigurationClass () default WebAutoConfiguration.class ), या @Exclude annotlude का उपयोग करके किसी भी कॉन्फ़िगरेशन को अक्षम करें ? वर्ग।
IoCStarter की उपयोगिता मुख्य संदर्भ आरम्भिक वर्ग है।

ठीक है, सब कुछ तैयार लगता है, संदर्भ आरंभिक है, वेब डिफ़ॉल्ट पोर्ट 8081 पर काम करता है, लेकिन कोई लिंक नहीं है, और जब हम साइट पर जाते हैं, तो यह वास्तव में हमें कुछ भी नहीं देता है। खैर, आगे बढ़ते हैं।

आइए हमारे मॉड्यूल के लिए एक कॉन्फ़िगरेशन फ़ाइल बनाएं। डिफ़ॉल्ट रूप से, सभी कॉन्फ़िगरेशन {working_dir} /configs/default_settings.properties से लोड किए गए हैं - हम इसे उपयुक्त पथ के साथ बनाएंगे।

 # Threading ioc.threads.poolName=shared ioc.threads.availableProcessors=4 ioc.threads.threadTimeout=0 ioc.threads.threadAllowCoreTimeOut=true ioc.threads.threadPoolPriority=NORMAL # Event dispather # -  ()    ( ) ioc.dispatcher.availableDescriptors=4 # Cache #   (EhFactory|GuavaFactory) cache.factory=org.ioc.cache.impl.EhFactory # Datasource #   (-, -  ) #LOCAL, LOCAL_SERVER, REMOTE datasource.orient.database-type=LOCAL #   datasource.orient.url=./database #    (   ) datasource.orient.database=orient #   datasource.orient.username=admin #   datasource.orient.password=admin #       (create, dropCreate, refresh, none) datasource.orient.ddl-auto=dropCreate #   ,      datasource.orient.showSql=true # Web server #     web.server.port=8081 #   SSL  web.server.ssl-enabled=false # in seconds #   ( 7200 . = 2 ) web.server.security.session.timeout=300 #  - web.server.velocity.input.encoding=UTF-8 web.server.velocity.output.encoding=UTF-8 #  - web.server.velocity.resource.loader=file #   web.server.velocity.resource.loader.class=org.apache.velocity.runtime.resource.loader.FileResourceLoader #    - web.server.velocity.resource.loading.path=./public 

अगला, हमें एक उपयोगकर्ता इकाई और उसके प्रबंधन भंडार की आवश्यकता है:
TblAccount इकाई का कार्यान्वयन:

 package org.examples.webapp.domain.entity; import org.ioc.web.security.user.UserDetails; import javax.persistence.*; import java.util.Collections; import java.util.List; @Entity public class TblAccount implements UserDetails { @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) private long id; @Column(name = "username") private String username; @Column(name = "password") private String password; @Transient private String repeatedPassword; public String getRepeatedPassword() { return repeatedPassword; } public void setRepeatedPassword(String repeatedPassword) { this.repeatedPassword = repeatedPassword; } @Override public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } @Override public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } @Override public List<String> getRoles() { return Collections.singletonList("ROLE_USER"); } } 

** स्पष्टीकरण:
सभी जेपीए-सपोर्टिंग फ्रेमवर्क के साथ सब कुछ मानक है। @ .Entity का उपयोग करके इकाई को मैप करें, @ .Id एनोटेशन का उपयोग करके प्राथमिक कुंजी बनाएं, @ कॉलम एनोटेशन का उपयोग करके कॉलम को मैप करें । और सुरक्षा मॉड्यूल में इकाई की पहचान करने के लिए UserDetails से विरासत में मिला।

TblAccountRepository इकाई रिपोजिटरी का कार्यान्वयन:

 package org.examples.webapp.domain.repository; import org.examples.webapp.domain.entity.TblAccount; import org.ioc.annotations.context.IoCRepository; import org.ioc.orm.repositories.CrudRepository; import javax.transaction.Transactional; @IoCRepository public interface TblAccountRepository extends CrudRepository<TblAccount, Long> { @Transactional TblAccount findByUsernameEq(String username); } 

** स्पष्टीकरण:
एनोटेशन @IoCRepository - इस संदर्भ से निर्धारित होता है कि वर्ग एक भंडार है और इसे "अलग तरीके" से संसाधित करने की आवश्यकता है।
मानक CRUD कार्यों का समर्थन करता है:

• Entity fetch (ID id) - डेटाबेस से Entity की एक इकाई प्राप्त करता है, या प्राथमिक कुंजी द्वारा कैश से;
• सूची fetchAll () - निकाय प्रकार की सभी संस्थाओं को प्राप्त करता है, उन्हें कैश में लोड करता है;
• शून्य सेव (इकाई इकाई) - डेटाबेस और कैश में दोनों प्रकार की इकाई की एक इकाई बनाता / अपडेट करता है;
• शून्य हटाना (इकाई इकाई) - डेटाबेस और कैश से दोनों प्रकार की इकाई हटाता है;
• बूलियन मौजूद है (आईडी आईडी) - चेक करता है कि क्या कोई इकाई प्राथमिक कुंजी का उपयोग करके डेटाबेस में मौजूद है।
  सभी CRUD अनुरोध एक लेनदेन में होते हैं।

यह खोजशब्दों के साथ कार्यों को ओवरराइड करके ऑटो-जेनरेशन का समर्थन करता है, जैसा कि ऊपर के कार्यान्वयन में है ( TblAccount findByUsernameEq (स्ट्रिंग उपयोगकर्ता नाम) ) और पंजीकृत प्रश्नों को कॉल करना ( NamedQuery )

फ़ंक्शन findByUsernameEq (स्ट्रिंग उपयोगकर्ता नाम) - इसके उपयोगकर्ता नाम फ़ील्ड द्वारा एक इकाई की खोज करता है। उत्पन्न अनुरोध:

  select * from tbl_account where username = 'username' 

अगला, हमें व्यावसायिक तर्क के प्रबंधन के लिए एक स्तर की आवश्यकता है।
खाता सेवा कार्यान्वयन:

 package org.examples.webapp.service; import org.examples.webapp.domain.entity.TblAccount; import org.examples.webapp.domain.repository.TblAccountRepository; import org.examples.webapp.responces.IMessage; import org.ioc.annotations.context.IoCComponent; import org.ioc.annotations.context.IoCDependency; import org.ioc.web.model.http.Request; import org.ioc.web.security.configuration.SecurityConfigureAdapter; import org.ioc.web.security.encoder.bcrypt.BCryptEncoder; import org.ioc.web.security.user.UserDetails; import org.ioc.web.security.user.UserDetailsProcessor; import java.util.Objects; import static org.examples.webapp.responces.IMessage.Type.ERROR; import static org.examples.webapp.responces.IMessage.Type.OK; @IoCComponent public class AccountService implements UserDetailsProcessor { @IoCDependency private TblAccountRepository tblAccountRepository; @IoCDependency private BCryptEncoder bCryptEncoder; @IoCDependency private SecurityConfigureAdapter securityConfigureAdapter; @Override public UserDetails loadUserByUsername(String username) { return tblAccountRepository.findByUsernameEq(username); } public void save(TblAccount tblAccount) { tblAccountRepository.save(tblAccount); } public void delete(TblAccount tblAccount) { tblAccountRepository.delete(tblAccount); } public IMessage tryCreateUser(String username, String password, String repeatedPassword) { if (username == null || username.isEmpty() || password == null || password.isEmpty() || repeatedPassword == null || repeatedPassword.isEmpty()) { return new IMessage(ERROR, "Invalid request parameters!"); } if (!Objects.equals(password, repeatedPassword)) { return new IMessage(ERROR, "Repeated password doesn't match!"); } final UserDetails userDetails = loadUserByUsername(username); if (userDetails != null) { return new IMessage(ERROR, "Account already exists!"); } final TblAccount account = new TblAccount(); account.setUsername(username); account.setPassword(bCryptEncoder.encode(password)); save(account); return new IMessage(OK, "Successfully created!"); } public IMessage tryAuthenticateUser(Request request, String username, String password) { if (username == null || username.isEmpty() || password == null || password.isEmpty()) { return new IMessage(ERROR, "Invalid request parameters!"); } final UserDetails userDetails = loadUserByUsername(username); if (userDetails == null) { return new IMessage(ERROR, "Account not found!"); } if (!bCryptEncoder.match(password, userDetails.getPassword())) { return new IMessage(ERROR, "Password does not match!"); } securityConfigureAdapter.getContext().authenticate(request, userDetails); return new IMessage(OK, "Successfully authenticated"); } public IMessage logout(Request request) { if (securityConfigureAdapter.getContext().removeAuthInformation(request)) { return new IMessage(OK, "/"); } return new IMessage(ERROR, "Credentials not found or not authenticated!"); } } 

** स्पष्टीकरण:
एनोटेशन @IoCComponent - एक घटक के रूप में एक वर्ग को शुरू करने का कार्य करता है।
एनोटेशन @IoCD निर्भरता - एक वर्ग की आवृत्ति में निर्भरता को इंजेक्ट करने के लिए प्रयुक्त ।
BCryptEncoder उपयोगिता पासवर्ड एन्क्रिप्शन (अब तक केवल कोडेक) के लिए BCrypt कोडेक का कार्यान्वयन है।
सिस्टम उदाहरण SecurityConfigureAdapter - का उपयोग मैपिंग अनुरोधों और उपयोगकर्ता सत्र के साथ काम करने के लिए किया जाता है।
UserDetails loadUserByUsername - विरासत में मिला फ़ंक्शन UserDetailsProcessor , सत्र में उपयोगकर्ता को लोड करने और प्रमाणीकरण ध्वज ( सुरक्षा में प्राधिकरण के मानक मानचित्रण के लिए भविष्य में) सेट करने के लिए कार्य करता है
IMessage फ़ंक्शन tryCreateUser एक उपयोगकर्ता निर्माण फ़ंक्शन है।
IMessage function tryAuthenticateUser - उपयोगकर्ता प्रमाणीकरण फ़ंक्शन।
IMessage लॉगआउट फ़ंक्शन एक अधिकृत उपयोगकर्ता से एक सत्र को साफ़ करने के लिए एक फ़ंक्शन है।
IMessage class ब्राउज़र (json response) में हमारे द्वारा आवश्यक जानकारी प्रदर्शित करने के लिए एक उपयोगिता वर्ग है।

 package org.examples.webapp.responces; public class IMessage { private final String message; private final Type type; public IMessage(String message) { this.message = message; type = Type.OK; } public IMessage(Type type, String message) { this.message = message; this.type = type; } public String getMessage() { return message; } public Type getType() { return type; } public enum Type { OK, ERROR } } 

अब आपको स्वयं लिंक के कार्यान्वयन की आवश्यकता है (अनुरोध मानचित्रण):

 package org.examples.webapp.mapping; import org.examples.webapp.domain.entity.TblAccount; import org.examples.webapp.responces.IMessage; import org.examples.webapp.service.AccountService; import org.ioc.annotations.context.IoCDependency; import org.ioc.annotations.web.IoCController; import org.ioc.web.annotations.Credentials; import org.ioc.web.annotations.MappingMethod; import org.ioc.web.annotations.RequestParam; import org.ioc.web.annotations.UrlMapping; import org.ioc.web.model.ModelAndView; import org.ioc.web.model.http.Request; @IoCController @UrlMapping("/") public class MainMapping { @IoCDependency private AccountService accountService; @UrlMapping public ModelAndView index() { final ModelAndView modelAndView = new ModelAndView(); modelAndView.setView("index"); return modelAndView; } @UrlMapping(value = "signup", method = MappingMethod.POST) public IMessage createUser(@RequestParam("username") String username, @RequestParam("password") String password, @RequestParam("repeatedPassword") String repeatedPassword) { return accountService.tryCreateUser(username, password, repeatedPassword); } @UrlMapping(value = "signin", method = MappingMethod.POST) public IMessage auth(Request request, @RequestParam("username") String username, @RequestParam("password") String password) { return accountService.tryAuthenticateUser(request, username, password); } @UrlMapping("signout") public IMessage signout(Request request) { return accountService.logout(request); } @UrlMapping("loginPage") public ModelAndView authenticated(@Credentials TblAccount account) { final ModelAndView modelAndView = new ModelAndView(); modelAndView.setView("auth"); modelAndView.addAttribute("account", account); return modelAndView; } } 

** स्पष्टीकरण:
एनोटेशन @IoCController - एक नियंत्रक के रूप में संदर्भ में वर्ग की पहचान करने के लिए कार्य करता है (ब्राउज़र अनुरोध मैपर)
एनोटेशन @UrlMapping - इंगित करता है कि चैनल संचालकों द्वारा संसाधित अनुरोधों की उपस्थिति के लिए एक फ़ंक्शन / वर्ग का विश्लेषण करना आवश्यक है।
विकल्प:

• मूल्य - अनुरोध हमें चाहिए;
• विधि - प्रसंस्करण के लिए http विधि (GET, POST, PUT, आदि);
• भस्म - HTTP माइम प्रकार एक विशिष्ट प्रकार (वैकल्पिक) के अनुरोध की उपस्थिति की जांच करने के लिए;
• उत्पादन - प्रतिक्रिया में एक विशिष्ट सामग्री प्रकार को वापस करने के लिए http सामग्री-प्रकार (सामग्री-प्रकार: पाठ / html; चारसेट = utf-8, सामग्री-प्रकार: मल्टीपार्ट / फॉर्म-डेटा; सीमा = कुछ, आदि) वैकल्पिक।

एनोटेशन @RequestParam - अनुरोध से प्राप्त पैरामीटर का नाम निर्धारित करने के लिए कार्य करता है। चूँकि प्रतिबिंब के डिफ़ॉल्ट माध्यमों द्वारा विधि पैरामीटर का वर्तमान नाम प्राप्त करना असंभव है, इसलिए मैं एक अतिरिक्त जावास्सिस्ट निर्भरता को जोड़ने के लिए आलसी था, जिसे asm के साथ मिलाया जा सकता था। इसलिए, अनुरोध से प्राप्त इस पैरामीटर मानों को एम्बेड करने के लिए पैरामीटर का नाम निर्धारित करने की ऐसी विधि। GET प्रकार के लिए एक एनालॉग है - @PathVariable - ऑपरेशन का एक ही सिद्धांत ( POST के साथ संगत नहीं)।
@ क्रेडेंशियल एनोटेशन - अधिकृत उपयोगकर्ता के वर्तमान डेटा को सम्मिलित करने का कार्य करता है, अन्यथा यदि अधिकृत उपयोगकर्ता की जानकारी सत्र में नहीं है, तो यह शून्य हो सकती है।
अनुरोध वर्ग प्रणाली एक आने वाले अनुरोध के बारे में वर्तमान जानकारी है, जिसमें कोका, हेडर और एक उपयोगकर्ता चैनल शामिल है, जिसे बाद में पुश मैसेज को भेजा जा सकता है ... जिनके पास इस संबंध में पहले से ही किसी प्रकार की फंतासी है।
उपयोगिता वर्ग ModelAndView एक पृष्ठ मॉडल है जिसमें बिना एक्सटेंशन के संसाधन का नाम है, और संसाधन में एम्बेड करने के लिए विशेषता है।

यह सब प्रतीत होता है, लेकिन नहीं - आपको उपयोगकर्ताओं के लिए उपलब्ध मानचित्रण को निश्चित रूप से कॉन्फ़िगर करना चाहिए।

 package org.examples.webapp.config; import org.ioc.annotations.configuration.Property; import org.ioc.annotations.configuration.PropertyFunction; import org.ioc.web.security.configuration.HttpContainer; import org.ioc.web.security.configuration.SecurityConfigureProcessor; import org.ioc.web.security.encoder.Encoder; import org.ioc.web.security.encoder.bcrypt.BCryptEncoder; import org.ioc.web.security.filter.CorsFilter; import org.ioc.web.security.filter.CsrfFilter; @Property public class SecurityConfig implements SecurityConfigureProcessor { @Override public void configure(HttpContainer httpContainer) { httpContainer. configureRequests(). anonymousRequests("/", "/signup", "/signin"). resourceRequests("/static/**"). authorizeRequests("/loginPage", "ROLE_USER"). authorizeRequests("/signout", "ROLE_USER"). and(). configureSession(). expiredPath("/"); } @PropertyFunction public CsrfFilter csrfFilter() { return new CsrfFilter(); } @PropertyFunction public CorsFilter corsFilter() { return new CorsFilter(); } @PropertyFunction public Encoder encoder() { return new BCryptEncoder(); } } 

** स्पष्टीकरण:
@Property एनोटेशन - संदर्भ बताता है कि यह एक कॉन्फ़िगरेशन फ़ाइल है और इसे आरंभ करने की आवश्यकता है।
एनोटेशन @PropertyFunction - कॉन्फ़िगरेशन विश्लेषक को सूचित करता है कि यह फ़ंक्शन कुछ प्रकार देता है और इसे एक घटक (बिन) के रूप में आरंभ करना चाहिए।
इंटरफ़ेस SecurityConfigureProcessor - अनुरोधों के मानचित्रण को कॉन्फ़िगर करने के लिए उपयोग की जाने वाली उपयोगिता।
HttpContainer मॉडल वर्ग एक उपयोगिता है जो उपयोगकर्ता द्वारा निर्दिष्ट अनुरोधों के मानचित्रण को संग्रहीत करता है।
CsrfFilter वर्ग अमान्य अनुरोधों (CSRF यांत्रिकी के कार्यान्वयन) का एक फ़िल्टर है।
CorsFilter क्लास एक क्रॉस- ओरिजिनल रिसोर्स शेयरिंग फ़िल्टर है।

AnonymousRequests फ़ंक्शन - अनुरोधों के एक असीमित सरणी को स्वीकार करता है, इसके लिए अधिकृत उपयोगकर्ताओं और रोल चेकिंग (ROLE_ANONYMOUS) की आवश्यकता नहीं होती है।
ResourceRequests फ़ंक्शन - असीमित सरणी अनुरोधों में लेता है, विशेष रूप से यह निर्धारित करने के लिए कार्य करता है कि संसाधन फ़ाइल किस पथ पर होगी जिसे जटिल प्रसंस्करण (सीएसएस, जेएस, चित्र, आदि) की आवश्यकता नहीं है।
फंक्शन ऑथराइज़प्रिसेस - असीमित अनुरोधों में लेता है, इसके लिए एक अधिकृत उपयोगकर्ता और उपयोगकर्ता में निहित विशिष्ट भूमिका की आवश्यकता होती है।
समय-समय पर समाप्त हो चुके सत्र को क्लियर करते समय एक्सपायरडपैथ फ़ंक्शन - उपयोगकर्ता इस मैपिंग (रीडायरेक्ट लिंक) द्वारा पुनर्निर्देशित होता है।

खैर, पृष्ठ, स्क्रिप्ट और साइट शैलियाँ थीं (मैं गहराई तक नहीं गया)।

 <html> <head> <meta charset="utf-8"/> <title>IoC Test</title> <link rel="stylesheet" href="/static/css/bootstrap.min.css"> <link rel="stylesheet" href="/static/css/style.css"/> <link rel="stylesheet" href="/static/css/pnotify.custom.min.css"/> <link rel="stylesheet" href="/static/css/pnotify.css"/> <link rel="stylesheet" href="/static/css/pnotify.buttons.css"/> </head> <body> <div class="container"> <h1>IoC Starter Test</h1> <br> <h4>Create user</h4> <br> <form id="creation"> <label for="username">Username: </label> <input type="text" id="username" name="username" class="color-input-field"/> <label for="password">Password: </label> <input type="password" id="password" name="password" class="color-input-field"/> <label for="repeatedPassword">Repeate: </label> <input type="password" id="repeatedPassword" name="repeatedPassword" class="color-input-field"/> <button type="button" class="btn btn-success btn-create">Sing up!</button> </form> <h4>Authenticate</h4> <br> <form id="auth"> <label for="username">Username: </label> <input type="text" id="username" name="username" class="color-input-field"/> <label for="password">Password: </label> <input type="password" id="password" name="password" class="color-input-field"/> <button type="button" class="btn btn-danger btn-auth">Sing in!</button> </form> </div> <script type="text/javascript" src="/static/js/jquery.js"></script> <script type="text/javascript" src="/static/js/bootstrap.min.js"></script> <script type="text/javascript" src="/static/js/scripts.js"></script> <script type="text/javascript" src="/static/js/pnotify.js"></script> <script type="text/javascript" src="/static/js/pnotify.buttons.js"></script> </body> </html> 

 <html> <head> <meta charset="utf-8"/> <title>IoC Test</title> <link rel="stylesheet" href="/static/css/bootstrap.min.css"> <link rel="stylesheet" href="/static/css/style.css"/> <link rel="stylesheet" href="/static/css/pnotify.custom.min.css"/> <link rel="stylesheet" href="/static/css/pnotify.css"/> <link rel="stylesheet" href="/static/css/pnotify.buttons.css"/> </head> <body> <div class="container"> <h1>Authorized page</h1> <br> <h4>Test auth data</h4> <div id="auth_data"> #if($!account) <h4>Hello @$!account.username, You successfully authenticated!</h4> <br> <button type="button" class="btn btn-success btn-logout">Logout!</button> #end </div> </div> <script type="text/javascript" src="/static/js/jquery.js"></script> <script type="text/javascript" src="/static/js/bootstrap.min.js"></script> <script type="text/javascript" src="/static/js/scripts.js"></script> <script type="text/javascript" src="/static/js/pnotify.js"></script> <script type="text/javascript" src="/static/js/pnotify.buttons.js"></script> </body> </html> 

 $(function () { $(".btn-create").click(function () { var cooki = cookie(); document.cookie = 'CSRF-TOKEN=' + cooki; $.ajax({ url: "/signup", data: $('#creation').serialize(), headers: {'X-CSRF-TOKEN': cooki}, crossDomain: true, xhrFields: { withCredentials: true }, type: "POST" }).done(function (data) { switch (data.type) { case 'OK': new PNotify({ title: 'Success', text: data.message, type: 'success', hide: false }); break; case 'ERROR': new PNotify({ title: 'Error', text: data.message, type: 'error', hide: false }); break; } }); }); $(".btn-auth").click(function () { var cooki = cookie(); document.cookie = 'CSRF-TOKEN=' + cooki; $.ajax({ url: "/signin", data: $('#auth').serialize(), headers: {'X-CSRF-TOKEN': cooki}, crossDomain: true, xhrFields: { withCredentials: true }, type: "POST" }).done(function (data) { switch (data.type) { case 'OK': new PNotify({ title: 'Success', text: data.message, type: 'success', hide: false }); setTimeout(function () { window.location = "/loginPage"; }, 5000); break; case 'ERROR': new PNotify({ title: 'Error', text: data.message, type: 'error', hide: false }); break; } }); }); $(".btn-logout").click(function () { $.ajax({ url: "/signout", crossDomain: true, xhrFields: { withCredentials: true }, type: "GET" }).done(function (data) { switch (data.type) { case 'OK': new PNotify({ title: 'Success', text: 'Logouting...', type: 'success', hide: false }); setTimeout(function () { window.location = data.message; }, 5000); break; case 'ERROR': new PNotify({ title: 'Error', text: data.message, type: 'error', hide: false }); break; } }); }); }); function cookie(a) { return a // if the placeholder was passed, return ? ( // a random number from 0 to 15 a ^ // unless b is 8, Math.random() // in which case * 16 // a random number from >> a / 4 // 8 to 11 ).toString(16) // in hexadecimal : ( // or otherwise a concatenated string: [1e7] + // 10000000 + -1e3 + // -1000 + -4e3 + // -4000 + -8e3 + // -80000000 + -1e11 // -100000000000, ).replace( // replacing /[018]/g, // zeroes, ones, and eights with cookie // random hex digits ) } 

संकलन करें, हमारे पास जो कुछ भी है उसे चलाएं।
यदि सब कुछ सही है, तो हम डाउनलोड के अंत में कुछ इस तरह देखेंगे:

परिणाम:
1) होम पेज

2) पंजीकरण

3) प्रमाणीकरण

4) प्राधिकरण परिणाम वाला पृष्ठ (लॉगिन और पासवर्ड सही ढंग से दर्ज करने के बाद पुनर्निर्देशित)

5) सत्र से प्राधिकरण जानकारी को साफ़ करना और उपयोगकर्ता को प्रारंभ पृष्ठ पर पुनर्निर्देशित करना

6) अनधिकृत उपयोगकर्ता द्वारा सत्र प्रमाणीकरण जानकारी के साथ पृष्ठ पर पहुंचने का प्रयास

अंत

यह परियोजना विकसित हो रही है, "योगदानकर्ताओं" और मूल विचारों का स्वागत है, क्योंकि इस परियोजना को अकेले करना कठिन है।
प्रोजेक्ट रिपॉजिटरी ।
प्रसंग
ओआरएम फैक्ट्री
वेब फैक्ट्री
उदाहरण
लेख से वर्तमान उदाहरण
रिपॉजिटरी पर भी 'उदाहरण' मॉड्यूल में सभी कार्यक्षमता का उपयोग करने के उदाहरण हैं , और जैसा कि वे कहते हैं, "गुड लक, मज़े करें", आप सभी का ध्यान देने के लिए धन्यवाद।