table of Contents
First, preface .....................................................................................
Second, the problem is defined .........................................................................
Third, design goals. ................................................................................. 2
Fourth, design task ............................................................................... 2
5. Feasibility can be analyzed ......................................................................... 3
Sixth, overall design ............................................................................. 5
Seven, mycollege.net neutron system architecture .................................................... 7
8. Application system development processes advocated by mycollege.net ...........................................
IX, ICOLLEGE.NET identity authentication and authority control strategy ...............................................
Ten, mycollege.net public data resource data access strategy ........................................ 11
11. Key technologies in the unified identification subsystem ............................................... 12
12, system test ...........................................................................................................................
Thirteen, small knots .....................................................................................
14th, reference ...................................................................................
Mycollege.net system planning and overall design
Wang Yun
School of Computer and Information Science, Southwest Normal University, Chongqing 400715, China
Summary: MyCollege.NET system adopts XML-based open structure, providing a new idea for the development and application of other application systems within MyCollege.Net. Application system can improve the unified authentication service and public resource sharing services provided by MyCollege.net, improve the complexity of various data resources in system-level, simplify system development, enhance system functions, and enhance user login experience. Aspects receive good results.
Abstract: The system named MyCollege.Net, which uses opened architecture based on XML, provides a fresh idea and method for its internal subsystems and other applications The applications can make data more re-usable on system level and achieve better effect on simplifying system. DEVELOPMENT, ENHANCING SYSTEM FUNCTION AND User Logon Experience Through The Universal Identity Authentication Service and The Common Resource Sharing Service of MyCollege.net Core Subsystems.
Keywords WebService unified identity authentication subsystem public resource management and shared subsystem
I. Introduction
In the development of MyCollege.net system, as a leader, I am mainly responsible for the planning and overall design of the entire system, responsible for coordination between group members and provides technical support. A corresponding solution is proposed for problem definitions, identifying the two core subsystems of MyCollege.net and delineates their respective functions and demonstrates the feasibility of developing the system. In order to reduce the difficulty of other group members to develop various subsystems, I defined the software architecture of the core subsystem development, and the system agency for the core subsystem provides a reference. Finally, the development processes, identity authentication, and data access should be developed under MyCollege.net.
Second, the problem definition
Between different information management systems in colleges, such as library management systems and student status management systems, there are functions for system users, different users have different usernames, passwords, permissions, etc. User authentication and authorization control issues must be handled in different information management systems in traditional development methods. However, in fact, their processing is basically consistent, because this function cannot be multiplexed between different systems, which causes the system's repetitive development. On the other hand, when a particular person acts as a user with specific permissions in a plurality of different information management systems, he needs to be repeated in each system, and it is necessary to remember information such as username and password under different systems. This naturally brings a well-known person to safety problem: if he uses the same username and password, then once it accidentally leaked out, it will be unimaginable; if he uses a completely different user name and password, then he needs to remember these different Information, this is undoubtedly a challenge for users. Therefore, whether there is a way to let the user register for a limited service in different systems, avoid repeated registration? We have found that the above book management system and the student status management system will use the basic information of the students and the student management system, and there are many other information management systems. These basic information is used. So is the basic information stored on a separate database server or put on a separate server?
In the previous mode, other systems should be remotely connected to the database server, the structure of the student basic information database can not be easily changed once it is determined, otherwise it will move the whole body, resulting in unstable in other systems. And there is a cross-platform problem, although different application systems communicate with the database using standard SQL statements, how to communicate with the database when the information management system runs on a heterogeneous network environment or running on a different system platform Server interconnect is another tricky problem.
The latter manner although the database independence is stronger, it will bring data repeated storage, data inconsistency, and systematic duplication development.
Intrinsically, all of these applications lack a unified planning, multiplexing technologies in software engineering cannot be implemented in system-level, and the public data resources between systems cannot be shared, and communication collaboration is difficult to implement in system-level. So our design "XML-based open integration system (MyCollege.net) design and development" tries to make a unified plan for this issue, give a solution to a perfect solution. At the same time, comply with the trend of modern software network, and strengthen the ability to synergy through the network between various apps.
Third, design goals
Integrated, existing, existing, and future applications in universities in a flexible way, providing the most basic services to these applications, maximizing the extent of resource sharing between various application systems, enhances different applications The synergy between the system is finally promoted by the network management of colleges and universities.
Fourth, design tasks
The support environment running MyCollege.Net is a Unified Authentication Subsystem (UIA) and a public resource management and a shared subsystem (CRESOURCE). These two core subsystems provide a support environment for the development of other subsystems in MyCollege.net. It should be noted that the application system and subsystem are the same concept under MyCollege.net, and all application systems are integrated into subsystems under MyCollege .NET.
The public class score management subsystem is to facilitate the public computer Ministry of Education to manage public classifications and online release. The development of this subsystem is entirely under our mycollege.net, follows our MYCOLLEGE.NET to apply the system development process, using various services in MyCollege.net, including unified identity authentication, concentrated based on Role authorization control and access to public data resources. On the other hand, the successful development of the system and the smooth integration of MyCollege.NET core subsystem will also prove advanced and feasibility of MyCollege.net design. V. Feasibility analysis
Develop such a complex system, can it be able to achieve the expected effect? Through the description of the above design tasks, we know that the core part of the system is UIA and CRESOURCE, and the biggest difficulty is to find a flexible, simple technology to implement data transmission and exchange of data in a network environment. This technology must be standard , Cross-platform, network structure is independent. Fortunately, on the Microsoft.Net platform, there is a technology called WebService, which can fully meet our requirements. At the same time, there are many other advantages in the .NET platform, which is now described below:
(1) Features of Microsoft.Net
1. Create a highly distributed application
The trend of business applications has always been a highly distributed model. The next generation of applications should be distributed in each mechanism. It forms a distinct contrast with today's main model - in today's mainstream model, all elements of the application (except browser-based clients) are located inside one institution.
2, simplify software development
Developers need to be able to focus on the business logic processing section of the application, rather than writing logical code for status management, scalability, etc. In .NET, writing Internet applications does not require too many Internet specific technical knowledge.
3, better user interface on the web
User interface development for Internet also needs to be as similar to local access as much as possible. Although using the local Wubdiws interface than the browser more excellent flexible interface, this interface requires a special run platform (.NET), do not guarantee that each client is installed .NET.
4, simplify deployment
DLL Hell's question and a large number of workloads required to install a form-based application are
Two examples of pre-deployment issues. The goal of .NET is to make its deployment and simply on DOS - simply copy the compiled module to the system. There is no need to register, there is no GUID.
5, support for various languages
All language supports .NET use the same data type and interface specification, which enables all .NET language to interactively interact. A language can easily call another language and even inherit the class prepared in another language, and expand them, and other platforms do not have this level of language interoperability.
6, platform scalability
.NET is fully object-based approach to expand the basic function by inheritance. The function of this platform is roughly divided into several parts. Allows part to be replaced with a new version when needed. In the future, it is likely to add new ways to the outside world to Windows Form, Web Form, and Web services. The architecture of .NET makes this very practical.
7. Future portability
.NET as much as possible abstract out of the bottom platform, separated the operating system. The programmer is not the operating system but a unified .NET platform. The main components of .NET have submitted to standardized organizations and intend to standardize the core of .NET in different operating systems. Such a final goal is to compile, movable to another .NET in different operating systems, no changes.
(2) WebService mechanism
In .NET, a WebService is a programmable unit that provides a range of services such as some business processing. And by using the Internet (such as XML and HTTP), this service can be utilized by many different systems. It is because XML and other Internet standards, compatibility between various programs is solved, and WebService becomes a reality. WebService uses four modules: Directory, Discovery, Description, and Wire Format to describe and provide a standard data transfer format. Directory provides a centralized location for webservice providers to publish information about the WebService they develop. Discovery is used to help the WebService client understand the existence of WebService and where to find WebService's description documentation. Description Defines the behavior of WebService and telling the WebService client how to use it. To ensure universality, WebService uses open protocols that can be used by all systems that support the most frequently used Web standards, such as the usual HTTP and SOAP (Simple Object Access Protocol) protocols. SOAP is the core protocol of WebService, which is a light protocol based on information exchange in dispersion and distribution environments. Sixth, overall design
XML-based open integration system (MyCollege.net) provides an open architecture to integrate existing, existing and future applications within campus; providing flexible system data exchange formats with XML technology Enhance the synergy between systems, reduce redundant development of various application systems, and improve application system development efficiency. The overall structure of the system is as follows:
There are two core subsystems in MyCollege.NET: Unified Authentication Subsystem (UIA) and Public Resource Management and Shared Subspace (CRESOURCE). These two core subsystems provide a support environment for the development and operation of other application systems in MyCollege.net.
The unified identity authentication subsystem provides unified application system identity authentication and user identity authentication services, focusing on role-based authorized control services. Unified identity certification subsystem single landing technology improves the login experience in different application systems. Just like Microsoft .Net Passport, users only need to log in, automatically log in automatically when accessing other application systems, no need to enter usernames and passwords. Any user registered in the unified identity authentication subsystem can use a unified identity identifier in the entire MyCollege.net, which will be automatically logged in when switching between different application systems. Application systems have strict authorization controls for users' authorization access and user publishing for personal privacy information.
Public resource management and shared subsystems offer public data resources most commonly used in MyCollege .Net, and publish these data resources through WebService technology to the network, application systems can be controlled by networks. . Different application systems have different read and write access to different resource types and resource properties. Such various application systems will have strong flexibility, and developers can develop corresponding data access policies for the future operating environment (such as network conditions, etc.), reducing data storage redundancy, enhancing data update The synchronization, the cross-platform sexual aspects of data is used.
Public data resources are such data resources: it is the intersection of data resources used by a set of applications. If this intersection does not exist in CRESOURCE, Cresorce's administrators can create this resource through the management capabilities in CRESOURCE and set it. Attributes. All of this is enough to ensure that the public data resources meet the vast majority of application system requirements, and maximize the sharing of public data resources. In our CResource, it contains at least the school's departmental professional setting information and student's basic information such as student number, name, gender, etc. As for if the student is transient, the details of the transposition should not be saved in CRESOURCE because it should be stored and processed by the Study Management System. The public class score management subsystem will be developed separately as a relatively independent system, which will be integrated with mycollege.net after development.
Integration between individual subsystems is a WebService technology, and since each subsystem is published on its own web service, it is also necessary to request a web service provided by other subsystems, so all subsystems are loose through the call between WebService. Coupled together.
The work procedure of the public class score management subsystem under MyCollege is illustrated by illustrating:
If the user wants to use Course2, he is redirected by the "landing" button in the UIA when requested to log in, and the user enters his username and password. UIA will verify the information and the user after authentication. The permissions (roles) of Course2 are returned to Course2, so Course2 completes the authentication and permission assignment of the user with the UIA. During the user using Course2, you may have to access the basic information of a student. Course2 first queries data in the local database, if the data does not exist, the WebService interface in CRESOURCE gets data, and processes. Finally, when the user is ready to leave Course2, he quits the "Safe Exit" button in the UIA. Or automatically log in to other application systems via single-point landing technology. If the user does not have a uniform identity or not with the use of course2, then he can apply for a unified identity on the UIA and apply for permissions in course2. If you agree with your application and enable your role, you can use Course2 using your username and password.
Seven, mycollege.net neutron system architecture
In a large application system, a simple representation of layers, logical layers, and data access layers do not meet the requirements. Mycollege.net combines the feature of the .NET platform to expand the simple three-layer structure, enabling it to meet the needs of most application systems in the network environment, developing the various subsystems and application systems under MyCollege. To the role of guiding. The expansion architecture is shown below:
Indicates that there are two forms of Windows Form and Web Form, corresponding to the C / S structure and B / S structure. Two structures that can coexist through WebService technology, and the development of the C / S structure is very simple on the .NET platform, hardly considering a deep network programming.
The logical layer is detained as a BusinessFacade and a business logic (BusinessRules). The former is mainly the business logic dispersed in the package application, providing a simple-stateless call interface to the representation layer. It is actually a precise description of the system requirements in the function interface layer, ie the functions in this layer class fully express the functions involved in the system requirements. Thus, once the layer is designed, the developer representing the layer can develop independent interface using this layer. The BusinessRules layer is mainly expressing business rules. For example, for authentication of the user email address in the UIA, the simple verification condition is that the @ symbol must contain @ symbols in the Email address, and the complex verification method will see if the address is exist and valid. Validation for Email is a business rule that should be processed in the BusinessRules layer. The WebService layer is a newly appeared layer in this architecture. It is actually equivalent to the web version of the BusinessFacade layer, some of the systems may need to be open and published via the Internet, and allow users to customize different user interfaces for these features (eg C / S and B / S).
Data Access Layer (DataAccess) is responsible for the processing of the database, which only adds deletion modifications to the data in the database, and does not consider whether these operations meet the business rules, and therefore important operations must be called through the review of the BusinessRules layer. The DataAccess layer is generally based on the ADO.NET layer on the .NET platform, you can flexible operations on the database, but in order to simplify the development of the system, Microsoft provides a set of tools Microsoft Data Application Block (DAB). Simplify the use of ADO.NET. Our DataAccess layer can be built directly on the DAB layer, which can meet the requirements in most cases. Of course, you can also mix in two ways.
The last layer is a Model layer. After designing such a complex system structure, we have to consider a problem: how the data between the layers is delivered. How to pass the DataSet extracted from the database to the BusinessFacade layer or businessRules layer? Due to the data format used in each layer design, how can I perform format conversion during the transfer process? The appearance of the Model layer is solving this problem, which defines the data structure of the data entity passed between the layers, which can be replaced by DataSet in ADO.NET, or use custom classes to implement, two The way each has its own advantages and disadvantages.
In the N layer structure, the call relationship between the layers must follow certain principles so that the advantages of the hierarchical structure can be reflected. In general, each layer can only be called by its upper layer, and cannot be called the same layer or the next layer. A function involving business rules in the BusinessFacade layer first calls the businessRules layer, which completes the implementation of the business rules and invokes the DataAccess layer to perform specific database operations. Functions that do not involve business rules can be done directly through the DataAccess layer. The WebService layer is almost the same as the BusinessFacade layer, and the difference is that it can call the function in BusinessFacade (equivalent to the call of the same layer). The DataAccess layer can be called any of the lowest layers. The Model layer can be called by DataAccess and any hierarchy of DataAccess due to the media exchanged between the layers.
There is a description herein about the status between the layers. The status is that the object remains existence and is available within the specified time to provide access support for attribute access and event excitation. For example, in the DataAccess layer, you can open the database connection and keep the connection state so that you can start at the last place at each access, without reopening the data connection and lookup. Although more flexible access data in a stateful system, the system's overhead may be very large. For example, in a database connection, if the connected user increases from 10 to 1000, then the database needs to maintain 1000 open connections, which is very wasteful to system resources. The frequent creation of stateless objects is time-consuming, but it provides strong scalability. When the user increases, the corresponding object is immediately destroyed, and the system resources are released, and the system is increased. There is a delay in the creation time of the object, but this can be solved by the cache function of the object pool. Our data objects (Model layer objects) delivered between the layers are obviously a stateless object, which is only responsible for transmitting a data entity and does not save any status. Therefore, if you are willing to use the stateless structure, it is best not to cache objects when you call the object. The above structure has strong flexibility, under mycollege.net, the development of each subsystem can refer to the above-described architecture and appropriate cropping. For example, in public resource management and shared subsystems, since the subsystem is equivalent to a network version of the DataAccess layer, it does not involve complex business logic, so it can remove the businessRules layer and add simple logic to the BusinessFacade layer.
8. Application system development processes advocated by MyCollege.net
(1) Register the application system into a member site of MyCollege.Net (Membersite)
The application system developer first applies for the UIA, requiring information such as a member of the UIA, and provides information such as user roles (equivalent to setting their users, such as administrators, tourists, etc.). If the developer's application is approved by the UIA administrator, he will get a USID, which will be the only identity indication of this application in myCollege.net.
(2) Develop your application system
At this point your application is already qualified to use the core service inside MyCollege.net. The first is to use the authentication provided by the UIA, based on role-based authorization control and single-point landing and other services. But this does not mean that the application must use these services, which can have some of the services that use them. For example, if the application system is not very strict, as long as the user in MyCollege.net can use this system, it can only use the identity authentication service without using the right to control service. However, MyCollege.net will strongly recommend that developers use all the features in the unified identity authentication subsystem, because so can not only improve the development efficiency of the application system, but also bring the user's users, such as single user names, single Easy to use the password and single landing and other use.
MyCollege.net is also included in public resource management and sharing services. Public resource management in MyCollege.NET manages a large number of data, and these data are public, essential, such as students' student, name, department, etc. Information; teachers' teachers, school department of professional information, etc. These public data resources are required for many campus applications. Any application system in MyCollege.NET can receive specific data after obtaining public resource management and shared subsystem authorized. The WebService technology used by MyCollege.Net will ensure that developers can easily use these data services on different network structures and system platforms. Now we know that there are two core subsystems and a large number of applications in MyCollege.net. In addition to providing services for both core subsystems, other application systems may also provide Web services outside. Our library management system can provide such services: querying students' borrows based on students' students' students. This newly added application can also use the web services provided by the application system existing in MyCollege.net.
(3) Installing your application for your application
In MyCollege.net, the application system is no longer an isolated stand-alone system, which is a network of software systems that use the network using MyCollege.net, which is the web service disclosed in other application systems (equivalent to Web services). ), While publishing your own web services (equivalent to the manufacturer of web services). They form a complex mesh structure and work together. Due to the network of networks and networks of the system, its installation deployment will be different from traditional desktop systems, and special measures must be taken to simplify the installation deployment of the system. In MyCollege.net, the installation deployment of the application system is made by the following recommendations:
Try to install the application system on the server side, doing the client's 0 installation, which is very simple for the B / S structure. For the C / S structure, since the Windows interface is used, it is required to run on the local client, but this does not mean that the client system must be installed on the client. In .NET, you can use a remote form to install the client system on the server, and then make a page with a hyperlink. The client is downloaded to a local cache when the client runs the system. This avoids the client installation deployment, thereby avoiding a large number of client version update issues brought by software upgrades. When the version is updated, you only need to redeploy it onto the server, and the incremental download technology in .NET will ensure that the client runs is always the latest version of the application.
(4) The operating environment of the application system
Since the application system is a component of MyCollege.Net, its normal operation is not allowed to support the support of the core subsystem and other application systems, so the normal operation of the application system must be guaranteed by a reliable network connection. For some pure data acquisition systems, developers can use special techniques (such as in this system) to reduce the dependence of the application for the network.
IX, ICOLLEGE.NET Identity Authentication and Permission Control Strategy
The identity authentication and permission control in MyCollege.net is very convenient and flexible, and the application system can choose the service in which the service is selected according to its own requirements.
Pure identity authentication strategy: Some application systems are not very high for security, such as student results query systems, as long as they have uniform identity under MyCollege.net, there is no strict authorization control for users. In this case, the identity authentication service in the UIA is very convenient, and the application system developer only needs to apply for registration and get your own USID, you can call the identity authentication service in the UIA.
Comprehensive use of identity authentication and authorization control: For applications with high security requirements, in addition to using UIA identity authentication services, the authorization control service using UIA is necessary. Authorization control in the UIA is a centralized role-based authorization control. The application system developer provides the user role to the UIA to set to the UIA while the application acquires USID. For example, a typical application system includes administrators and general users. After the registration work in the UIA is completed, the developer can use the identity authentication and authority control service. Ten, public data resource access strategy in mycollege.net
There are three different policies for public data resources under MyCllege.NET: Synchronize Access Policy, Cache Policy, and Asynchronous Access Policy, three different strategies have excellent and application applications.
Synchronous Access Policy: The application system does not set a dedicated database or file to save the required public data resources. Whenever the application needs to use public data resources, you call the WebService in the CRESource subsystem through the network to get data, CRESOURCE Saved is the latest data under mycl DegeGe.NET system. Therefore, the policy ensures that the application system acquires the latest data to make the data in different application systems reach a high degree of consistency. The disadvantage of this data access is that the performance and reliability requirements of the network are relatively high, and the frequent calls of WebService in CRESOURCE will increase the burden on the CRESOURCE server in the application system.
Cache Policy: In this policy, the application system requires a local database to cache the required public data resources. The application system tries to retrieve data from the local database when accessing the required public data resources. If the local database is used directly, it is directly used. If there is no cache required in the local database, if you do not hit the local database, then get the latest data through the WebService, and take a certain cache policy to cache the obtained data into the local database to support the data. High-speed access. This is a bit similar to the working principle of virtual memory in your computer system. This data access policy overcomes harsh requirements for high-performance high reliability in the synchronization policy, as a large number of public data resources are cached in the local database. However, it introduces a problem, what should I do if the data is modified during access? Similar to virtual memory, which writes back policy to write the modified data back to CRESOURCE is a question worthy of application system developers.
Asynchronous Access Policy: This policy is similar to the cache policy, which is also necessary to set local databases in the application. However, in the process of data access, there is no cache policy in the cache policy, the application is only regular or irregular access to the CRESOURCE subsystem, obtain the latest public data resources, then update the local database, and the data after local update Write back to CRESOURCE. Although data updates cannot be synchronized, the public data resources for periodic update are compared.
Application system developers should consider the network environment and their own hardware facilities in the system operation, and the most suitable public data resource access strategy is developed according to these conditions.
11. Key technologies in the unified identity certification subsystem
The most critical technology in MyCollege.NET is the identity authentication and permission control in the UIA. Implementing identity authentication through the corresponding function in ASP.NET is very simple, but this simple function does not provide the function of attaching the user role in the page. So we must use the ASP.NET's identity authentication underlayer to implement the features of additional user roles. Below is some important code:
Login.ascx code to attach the user role in the control:
Private void Button1_Click (Object Sender, System.Eventargs E)
{
// Standardize the parameters and remove the extra spaces
String nickname = textBox1.text.trim ();
String password = textbox2.text.trim (); // call UIA's WebService to complete user authentication
IF (new businessfacade.usersystem (). Checkuser (Nickname, Password))
{
// Add the information from the user to the session
Model.userdata user = null;
User = new businessfacade.usersystem (). getuser (nickname);
THIS.Session ["user"] = user;
// Create an authentication ticket
FormsauthenticationalTicket Ticket = New FormsauthenticationTicket (1, Nickname, DateTime.Now, DateTime.now.addminutes (30), False, "/");
String hashticket = formsauthentication.encrypt (ticket);
Httpcookie usercookie = new httpcookie (formsauthentication.formie (formsauthentication.formie);
// Add to Cookies
Response.cookies.add (usercookie);
// Jump to the appropriate page
IF (this.Session]! = NULL)
Response.Redirect (this.Session]. Tostring (), true);
Else Response.Redirect ("Default.aspx", True;
}
}
The key code for recovering the username and role in Global.asax:
Protected Void Application_AuthenticateRequest (Object Sender, Eventargs E)
{
HTTPApplication APP = (httpapplication) Sender;
HTTPCONTEXT CTX = App.Context; // Get httpContext objects related to this HTTP request
If (ctx.request.isauthenticated == true) // Verified users to process ROLE processing
{
Formsidentity ID = (FormSIDENTITY) CTX.User.Identity;
FormsAuthenticationticket Ticket = id.ticket; // Tickets for authentication
String [] roles = ticket.userdata.split (','); // convert the Role data in the authentication ticket into a string array
CTX.user = new genericprincipal (id, roles); // Add a geneticPrincipal, add a genericprincipal, which is the current user, so that the current user has Role information.
}
}
12. System test
(1) Subsystem independent test
MyCollege.net system consists of two core subsystems and an application subsystem, and three subsystems are almost synchronized during the development process, so there is a need to conduct independent tests in the middle and later periods of development. Since the two core subsystems are quite a large part of the function is released through the WebService technology, if you want to perform a complete white box test through the interface, you must write the corresponding client test program, which obviously adds the development of the program. The debugging interface that uses WebService is very limited, so we mainly use black box test technology to review the code in independent test of subsystem. (2) Comprehensive test
MyCollege.net is an integrated system. Separate test success of subsystems does not guarantee the coordination of the entire system, so it is very important to ensure that the entire system is working properly. In the process of testing because there is already a subsystem integrated, a white box test technology is employed. The integrated test steps for the two core subsystems are as follows:
1. Integrated testing of CRESOURCE. A student information processing utility we developed is on the service provided by CRESOURCE. The SGET is mainly provided to query the basic information of the student's basic information online, and the keywords such as entering the school number or name are called from the CResource, and the SGET's successful operation can only explain the initial integration of CRESOURCE, because sget is only available. Where query function. Further tests for CRESOURCE are still to be performed. Below is an interface in the sget test.
2. Further comprehensive testing of UIA and CResource is done by public class score management subsystem course2 and student information processing utility SINPUT, as these two subsystems use the core subsystem of MyCollege.net. The two subsystems in the integrated test are carried out simultaneously because the user who wants to have a uniform identity in the UIA to switch between two different member sites, so the focus of this part of the test is to design a complete username test case. Due to the layout, only some test cases are listed below:
During the test case, we conducted a modification operation such as password modification and role applications. All results in Course2 and Sinput were expected, which fully illustrates our entire system to work. . Below is the unified login form in the form of the Windows Form in the UIASDK, the login failed information displayed under different cases:
Thirteen, small knot
In more than two months, I lead our team a successful completion of the task of graduation design. As the team leader of the entire group, I have more opportunities to participate in the various processes of graduation design, have a full understanding of the activities in software development. Graduation design is not only a technical job is a engineering work. It is not only our collaboration between the management method, the engineering method, the development method, and the members within the group. . During development, our team members show a high degree of collaborative work ability, which lays a good foundation for future engagement work. Due to the time relationship, some implementation has not reached the original design goal, and it should focus on solving the problem of single sign-on in the next development of the project. Finally, this graduation design can be successfully completed inseparable from our guidance.
Zou Xiangchun
Teacher guidance and help,
Lu Xinhong
teacher,
Chen Wu
teacher,
Smell
teacher,
Li Yun Gang
Teacher also gave great help in this process, expressing their sincere gratitude to their help. There is also a team of all members to support me, thank you for their heartfelt thanks!
14, reference
[1] Shao Weizhong, Yang Fuqing. Object-oriented system design. Tsinghua University Press.
[2] Fang Guiben et al. Machine Industry Press.
[3] Qi Zheng. Software Architecture. Xi'an Jiaotong University Press.
[4] Wu Yizhen. Object-oriented analysis design and programming. Tsinghua University Press.
[5] Wei Weihong translation. Advanced programming of the distributed data application. Tsinghua University Press. [6] Zhang Gong translated. VB.NET Advanced Programming. Tsinghua University Press.
