Example Title of the Presentation

Introduction to
Spring Python

Greg L. TurnquistSenior Software EngineerSpringSource

Adapted from presentation given at SpringOne 2008

What should you take away from this?

Spring Python gives you the tools to build dynamic, powerful, easy-to-maintain enterprise solutions

Who Am I?

A test-bitten script junky, always seeking better solutions for customer requirements

Worked as a software engineer for 11 years at Harris Corporation after graduating Auburn University with Master's in Computer Engineering. Joined SpringSource in 2010.

Have built mission critical systems, trained on-call support teams, evangelized usage of wikis, and utilized Agile practices to write top quality software

Active contributor to open source community: MythTV, Mediawiki, Spring Framework/Acegi, TestNG Eclipse plug-in

Find me at http://www.linkedin.com/in/GregLTurnquist

Who Am I?

Wrote Spring Python 1.1

Find detailed diagrams, lots of code examples, and information on how to build powerful Python applications using the Spring way.

http://springpythonbook.com

The Spring Framework provides many useful features, and I wanted those same features available in Python.

Agenda

History

Technology

IoC container

Database template

Transactions

Security

AOP

Remoting

Status

Current

Future of the project

When/where did it come from?

In October 2006 came the carputer

Needed utility of Spring with power of Python

In December 2006, made first release to Sourceforge

In July 2008, Russ Miles (SpringSource) invited Spring Python to be a Spring Extension

In June 2009, started writing Python 1.1 book

Becoming an extension

Since then:

Migrated code to Spring's subversion servers, and later to git

Worked with build team to setup Continuous Integration

Copied all tickets into JIRA (open and closed)

Setup Spring Python community forum, blog, and irc channel (#springpython)

Made 750+ commits; released versions 0.6-0.9, 1.0, and 1.1; closed 109 issues

Brought on board two more committers

Currently interacting w/many devs and users about future of Spring Python including roadmap for 1.2 and beyond

Agenda

History

Technology

IoC container

Database template

Transactions

Security

AOP

Remoting

Status

Current

Future of the project

We have the same concepts as Spring

SimpleObject

SimpleObject

Dependency Injection

AOP

Portable Service Abstractions

Multiple IoC formats supported

Started with an XML-based configuration

Later, a python decorator-based configuration

Recently rewrote IoC container, handles:

Original format (now called PyContainerConfig)

Newer, more sophisticated XML format (XMLConfig)

Spring Java's format (SpringJavaConfig)

Decorator-based @Object format (PythonConfig)

YAML-based format (YamlConfig)

New container can mix ANYTHING

Allows multiple sources in multiple formats

Objects can reference ANY other object

...no matter WHERE its defined

...and no matter WHAT format its defined in

Flexible IoC container + dynamic Python = High Value

Pure Python IoC

@Object-based configuration

class MovieBasedConfig(PythonConfig):

def __init__(self):

super(MovieBasedConfig, self).__init__()

@Object(scope.PROTOTYPE)def MovieLister(self):

lister = MovieLister()lister.finder = self.MovieFinder()lister.description = self.SingletonString()return lister

@Object(scope.SINGLETON)def MovieFinder(self):

return ColonMovieFinder(filename="support/movies1.txt")

Compare with Spring's IoC

Similar concepts found in Spring

Java = beans, Python = objects

@Object is like @Bean

Current scopes: SINGLETON and PROTOTYPE

FUTURE: Lazy initialization, auto-wiring

Newer concepts not yet found in Spring

One-and-only-one container type

FUTURE: Fluent API (DSL) configuration

Question

What database problem does Python have?

Answer

The Magic 8 says:
Same problem Java JDBC has!

Python's database issue

For every query:

Only difference between every query is SQL and row conversion

// open connection to database// create cursor// execute SQL query// for eachRow in resultSet

// convert row into an object

// close cursor// close connection

Why create DatabaseTemplate?

Spring's JdbcTemplate helped me write database queries fast in Java

Python apps have the same problem and need the same leverage

DatabaseTemplate should be reason enough for potential users to embrace Spring Python

ORMs and DatabaseTemplate

They provide quick way to persist objects.

But sometimes they are tricky for complex queries. What if...You need left outer joins that lack foreign key meta-data

You actually know what a left outer join is and don't need help

You are porting from ORM to another

You have a DBA team that can optimize your queries

How to code a query

Piece of PetClinic:

Use binding variables (?) to avoid SQL injection attacks

Each row of results is passed to callback

Notice lack of cursor management?

return databaseTemplate.query("""

SELECT id, first_name, last_name, address, city, telephoneFROM ownersWHERE upper(last_name) like ?""",("%" + lastName.upper() + "%",),OwnerRowMapper())

Immediate payoff

Benefits:

No cursors to manage

No ugly try/except blocks

Focus is on business logic

Query will work with any RDBMS*MySQL, Sqlite, PostGreSQL, Oracle

(*Okay, DB vendors can support different forms of binding variables, but we are ready for that!)

How to code a row mapper

The other side:

Very useful when you have to code a lot of Owner-based queries

class OwnerMapper(RowMapper):

def map_row(self, row):

owner = Owner()owner.id = row[0]owner.firstName = row[1]owner.lastName = row[2]owner.address = row[3]owner.city = row[4]owner.telephone = row[5]return owner

Question

Have you ever had to deal with transactions?

Transactions power the enterprise

Database calls are valuable for any app, small or large

Transactions power enterprise solutions

Coding transactions is one of the first demands for enterprise apps

How to code transactions

Spring Python makes it easy to programmatically code transactions

tx_mgr = ConnectionFactoryTransactionManager(factory)tx_template = TransactionTemplate(tx_mgr)dt = DatabaseTemplate(factory)

class txDefinition(TransactionCallback):

def do_in_transaction(s, status):

dt.execute("INSERT INTO animal (name) VALUES (?)",('black mamba',))dt.execute("INSERT INTO animal (name) VALUES (?)",('copperhead',))results = dt.queryForObject("SELECT nameFROM animal WHERE name like 'c%'", required_type=types.StringType)return results

print tx_template.execute(txDefinition())

>>> "copperhead"

Declarative transactions are key

TransactionTemplate is useful for a handful of transactions

However, marking business methods with @transactional catapults you into the enterprise

Decouples business logic from the database

How to declare transactions

class TransactionalBank(object): def __init__(self, factory): self.dt = DatabaseTemplate(factory)

@transactional(["PROPAGATION_REQUIRED"]) def deposit(self, amount, account_num): self.dt.execute("UPDATE account SET balance = balance + ? WHERE account_num = ?", (amount, account_num))

@transactional(["PROPAGATION_REQUIRED"]) def withdraw(self, amount, account_num): self.dt.execute("UPDATE account SET balance = balance - ? WHERE account_num = ?", (amount, account_num)) return amount

@transactional(["PROPAGATION_REQUIRED"]) def transfer(self, amount, from_account_num, to_account_num): self.withdraw(amount, from_account_num) self.deposit(amount, to_account_num)

Code is clean and easy to read

Declarative transactions move configuration to a central location

Your logic is clean, concise, and clear to its purpose

Enterprise apps tend to get HUGE, so maintainable code is paramount to success

Spring Python's declarative transactions are EXACTLY what you need

Spring Python 1.1 shows you the pros and cons of programmatic vs. declarative vs. AOP-based transactions.

Question

At what stage do developers code security into their apps?

Answer

HINT: Its usually not the first thing on your mind

Security done right is hard

Security is a big flaw in modern web apps

Security is typically done last and thus, often rushed

Rushed implementation = WRONG solution

Spring Python's security is the RIGHT solution

Authentication made easy

Authenticating a user is EASY

Uses AOP so your APIs don't change

Familiar with Spring Security? We borrowed their concepts.

Makes Spring Python powerful!

TODAY: In-memory (for testing), database, LDAP

FUTURE: X.509, OpenID, OpenSSO, Basic HTTP, 2-factor, anything!

Authorization also easy

Authorizing users is also easy

Spring Python is just as powerful

TODAY:

Role-based and/or Label-based voters+Affirmative- or Unanimous- or Consensus-based policies= Powerful, flexible, elegant configuration

FUTURE:

read-write-execute ACL voters for domain object security

Anything the community needs!

Question

What technology makes it easy to layer on services without changing APIs?

Answer

Survey says:

Aspect Oriented Programming

Spring makes AOP easy

Spring AOP = easy AOP for Java

Spring Python AOP = easy AOP for Python

Allows enterprise-style services to be easily built around your objects

Security, transactions, auditing, tracing, performance analysis

Many parts of Spring Python ride on AOP

AOP is part of the Spring triangle

SimpleObject

SimpleObject

Dependency Injection

AOP

Portable Service Abstractions

AOP, easy as 1-2-3

class SampleService: def method(self, data): return "You sent me '%s'" % data

service = SampleService()print service.method("something")

>>> "You sent me 'something'"

class WrappingSvc(MethodInterceptor): def invoke(self, invocation): return "" + invocation.proceed() + ""

service = ProxyFactoryObject(target = SampleService(), interceptors = [WrappingSvc()])print service.method("something")

>>> "You sent me 'something'"

Question

What can you do to make apps redundant and support more clients?

Answer

The answer behind door #3 is:

Spread your app across multiple nodes

Remoting links things together

Remoting is the building block for distributed systems

It allows you to split up apps that need more resources

Horizontal scaling allows you to grow your enterprise

Spring Python allows you to easily supply and consume remote services

Pyro today, REST & WS tomorrow

Today:

Pyro (Python remote objects) pure python RPC library

Hessian interoperable protocol

JMS link Python-to-Python or Python-to-Java with WebshereMQ

Tomorrow:

RESTful web services

COMET-enabled web apps

Twitter

Any web service, or other useful remoting protocol

Other JMS providers

Agenda

History

Technology

IoC container

Database template

Transactions

Security

AOP

Remoting

Status

Current

Future of the project

Top quality, production-ready

Just released 1.1.0.FINAL. Starting 1.2.

Has ALL key features needed for development

Top quality

Tied in to CI: nightly builds and trunk commits

Built from Day 1 using TDD => Code coverage at 85%

Powerful integration

CherryPy, Pyro, Hessian, MySQL, PostGreSQL, Sqlite, Oracle

Documentation is up-to-date and useful

Community support is important

Solutions

What solutions do python users need?

What 3rd party libraries can be enhanced or leveraged to provide integrated solutions?

Community

Striving to answer any/all questions posted to the forums

Provide fast support to email distribution list

Grow the community of users

Spring Python has a strong future

Quality is always #1 priority

Integrating with top-used tools is important

Django, Turbogears, Zope/Plone, Paste, Google App Engine, SpringSource Tool Suite, Jython, IronPython

Books, podcasts, slide shows, video tutorials, anything to support the community

Spring + Python = powerful solutions

Spring Python provides powerful, dynamic, and easy-to-maintain enterprise solutions

Useful project links

Web site: http://springpython.webfactional.com

Book: http://springpythonbook.com

Blog: http://blog.springpython.webfactional.com

Community forum: http://forum.springframework.org

Source code: https://src.springframework.org/svn/se-springpython-py/

Bug tracking: http://jira.springframework.org/browse/SESPRINGPYTHONPY

Mailing list: http://lists.springsource.com/listmanager/listinfo/springpython-users

CI: http://build.springframework.org/browse/EXT-PYSNAPSHOT

Fisheye: https://fisheye.springframework.org/browse/se-springpython-py

Thank you
for your attention

Slide

Slideshow is licensed under a Creative Commons Attribution 3.0 United States License.