BPMN

Tools to open vsd

https://www.lucidchart.com/pages/visio/vsd-viewer-mac
http://www.conceptdraw.com/
http://www.omnigroup.com/products/omnigraffle/

http://upload.wikimedia.org/wikipedia/commons/e/e3/BPMN_2.0_Accounts_Payable_business_process_map.jpg


http://www.bpmn.org/

Gateways
http://en.bpmn-community.org/tutorials/4/
Inclusive Gateway/Exclusive Gateway

• Inclusive or: A or B or both.
• Exclusive or: Either A or B but not both.

Petrit Net

http://www.informatik.uni-hamburg.de/TGI/PetriNets/introductions/aalst/

http://www.informatik.uni-hamburg.de/TGI/PetriNets/

A Petri net (also known as a place/transition net or P/T net) is one of several mathematical modeling languages for the description of distributed systems. A Petri net is a directed bipartite graph, in which the nodes represent transitions (i.e. events that may occur, signified by bars) and places (i.e. conditions, signified by circles). The directed arcs describe which places are pre- and/or postconditions for which transitions (signified by arrows) occurs. Some sources^[1] state that Petri nets were invented in August 1939 by Carl Adam Petri — at the age of 13 — for the purpose of describing chemical processes.

weight of arcs

Business_Process_Modeling_BPMN

Resource Description Framework (RDF)

N3(N-triple)Validator

N3 EXAMPLES

A Java Program that can read write N3

reference 

TERMS:

OWL: Web Ontology Languages 

RDF: RESOURCE DESCRIPTION FRAMEWORK 

example of RDF:

The fundamental concepts of RDF are: 
– resources
– properties
– statements 

Tutorial to RDF
http://www.rdfabout.com/quickintro.xpd
Tutorial to N3
http://www.w3.org/2000/10/swap/Primer
http://eulersharp.sourceforge.net/2004/02swap/RDFEngine/inferencing.htm
http://infomesh.net/2002/notation3/

Graphical Representations

http://www.infowebml.ws/rdf-owl/graphical-representations.htm#member

N3 Example:
 RDF triples

A student record in a database has the following fields: 
- name 
- major 
- student identity number 
- GPA 
- Advisor 

Model this database using RDF triples, by defining the classes and properties. Use the N3 notation. Give the triples for one example student record. 

:student rdf:type rdfs:Class.    //rdf:type  //student是 Class
:name rdf:type rdf:Property.  //name 是 Property
:major rdf:type rdf:Property.
:sin rdf:type rdf:Property.
:gpa rdf:type rdf:Property.
:advisor rdf:type rdf:Property.

:name rdfs:domain :student.  //Property - name 属于 student (Class student 拥有Property - name)
:major rdfs:domain :student.
:sin rdfs:domain :student.
:gap rdfs:domain :student.
:advisor rdfs:domain rdf:student.

student1 rdf:type :student.     //student1 是 student (instance)
student1 :name "Joe Smith".
student1 :major "Computer Science".
student1 :sin 12345678.
student1 :gpa 3.5.
student1 :advisor faculty17.

The property which tells you what type something is is rdf:type which can be abbreviated to N3 to just a. So we can define a class of person

:Person a rdfs:Class.

Define the following using OWL statements: 
1. A student has exactly one advisor. 
2. A student is uniquely identified by their SIN. 
3. Define the set of honor students as the set of all students whose GPA is 4.0. This is a very strong notion of honor student, but it greatly simplifies the question for you.

1. :advisor rdf:type owl:functionalProperty.

2. :sin rdf:type owl:inverseFunctionalProperty.

3. :honorStudent owl:equivalentClass

      [ a owl:Restriction ;

owl:onProperty :gpa ;

owl:hasValue .40 ]

rdf:domain v.s. rdf:range

There is an example here: http://www.w3.org/2000/10/swap/Primer

The property which tells you what type something is is rdf:type which can be abbreviated to N3 to just a. So we can define a class of person

:Person a rdfs:Class.

In the same document, we could introduce an actual person

:Pat a :Person.

Classes just tell you about the thing which is in them. An object can be in many classes. There doesn't have to be any hierarchical relationship -- think of Person, AnimateObject, Animal, TallPerson, Friend, and so on. If there is a relationship between two classes you can state it - check out the properties (of classes) in the RDF Schema and OWL vocabularies.

:Woman a rdfs:Class; rdfs:subClassOf :Person .

A property is something which is used to declare a relationship between two things.

:sister a rdf:Property.

Sometimes when a relationship exists between two things, you immediately know something about them, which you can express as a class. When the subject of any property must be in a class, that class is a domain of the property. When the object must be in a class, that class is called the range of a property. A property can have many domains and ranges, but typically one specifies one.

:sister rdfs:domain :Person; 
        rdfs:range :Woman.

Note the class identifiers start with capitals and properties with lower case letters. This is not a rule, but it is a good convention to stick to. Note also that because the domain of rdfs:range and rdfs:domain themselves is rdf:Property, it follows that :sister is a rdf:Property without it being stated explicitly.

rdfs:domain vs rdfs:range

Example 

"When the subject of any property must be in a class, that class is a domain of the property. When the object must be in a class, that class is called the range of a property."

http://workingontologist.org/Examples/Chapter3/shakespeare.n3
a Person linvedIn a Place

bio:livedIn
      a       owl:ObjectProperty ;
      rdfs:domain lit:Person ;//subject
      rdfs:label "lived in"^^xsd:string ;
      rdfs:range lit:Place . //object

Spring Note

Spring 

1. Annotation injection is performed before XML injection, thus the latter configuration will override the former for properties wired through both approaches.

Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider to have following configuration file in case you want to use any annotation in your Spring application.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>
   <!-- bean definitions go here -->

</beans>

Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us see few important annotations to understand how they work:

Maven-Spring

OPTION1

1. install m2Eclipse in Eclipse
2. Create maven project
3. create SOURCE FOLDER -> "sre/main/java/resources"
4. add config xml files to resources folder
5. add dependencies to pom.xml

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>3.8.1</version>

<scope>test</scope>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring</artifactId>

<version>2.5.6</version>

</dependency>

</dependencies>

...

Maven will download those dependencies automatically.

OPTION2

In mkyong's example, he established the maven project in linux and then import it into eclipse.
http://www.mkyong.com/spring/quick-start-maven-spring-example/

1. Generate project structure with Maven

In command prompt, issue following Maven command :

mvn archetype:generate -DgroupId=com.mkyong.common -DartifactId=SpringExamples 
 -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Maven will generate all the Java’s standard folders structure for you (besides resources folder, which you need to create it manually)

2. Convert to Eclipse project

Type “mvn eclipse:eclipse” to convert the newly generated Maven style project to Eclipse’s style project.

mvn eclipse:eclipse

Later, import the converted project into Eclipse IDE.

Create a resources folder (not folder)
Create a resources “/src/main/resources” folder, the Spring’s bean xml configuration file will put here later. Maven will treat all files under this “resources” folder as resources files, and copy it to output classes automatically.

3. Add Spring dependency

Add Spring dependency in Maven’s pom.xml file.

File : pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.mkyong.common</groupId>
 <artifactId>SpringExamples</artifactId>
 <packaging>jar</packaging>
 <version>1.0-SNAPSHOT</version>
 <name>SpringExamples</name>
 <url>http://maven.apache.org</url>
 <dependencies>
 
  <!-- Spring framework -->
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring</artifactId>
   <version>2.5.6</version>
  </dependency>
 
 </dependencies>
</project>

Issue “mvn eclipse:eclipse” again, Maven will download the Spring dependency libraries automatically and put it into your Maven’s local repository. At the same time, Maven will add the downloaded libraries into Eclipse “.classpath” for dependency purpose.

I have try this one but the eclipse complained that ApplicationContext and ClassPathXmlApplicationContext cannot be resolve although the spring framework are in the lib path.

Solution :
Convert the project to maven project in Eclipse. (Download m2eclipse firstly: help->install->m2eclipse)

The reason might be that eclipse didn't know what maven is.


OK, LET'S MOVE ON...


Why use XML to config the project?
loose coupling;