data编程代写、代做Java设计程序

项目预算：开发周期：发布时间：要求地区：

Your class project is the delivery of an executable software system that makes use of:
1. At least FOUR design patterns; and
2. At least SIX EIP patterns (you may not count the EIPs in RED in the list below in your count of six, as you will all be using these EIPs of
necessity by simply using ActiveMQ messaging).
To refresh your memory, here are the patterns we have (or will) cover during class or which are assigned as reading (with the lecture in which
they are assigned):
Design Pattern/Architectural Pattern Lecture Reading Assigned Enterprise Integration Pattern
Singleton 1 Message Broker
Template Method 2 Message
Composite 2 Message Endpoint
Strategy 2 Request-Reply
Iterator 2 Message Channel
Class Adapter 3 Point-to-Point Channel
Object Adapter 3 Publish-Subscribe Channel
Mediator 3 Polling Consumer
Observer 3 Event-Driven Consumer
State 4 Splitter
Prototype 4 Aggregator
Proxy 4 Message Router
Facade 5 Content-Based Router
Layers 5 Message Translator
Builder 5 Message Filter
Abstract Factory 6 Invalid Message Channel
Factory Method 6 Datatype Channel
Chain of Responsibility 6 Channel Adapter
Command 7 Messaging Gateway
Interpreter 7 Competing Consumer
Bridge 7 Selective Consumer
Visitor 8 Dynamic Router
Decorator 8 Correlation Identifier
Flyweight 8 Dead Letter Channel
Memento 8 Message Dispatcher
Pipes & Filters
NOTE you are NOT limited to the EIPs listed above right. You may choose any of the EIP patterns listed in the link below (with the exception
of the Message Broker, Message Endpoint, Message, Pipes & Filters, and Channel noted above):
The 65 Enterprise Integration Patterns Listing Enterprise Integration Pattern
NOTE likewise,, you are NOT limited to the Design Patterns listed above left. You may choose any of the Design Patterns listed here:
The 23 Gang of Four Design Patterns
You should produce a project proposal for review by me by 11:00 pm, April 29th, 2024. You are welcome to propose your project earlier than
that date. The project proposal will specify a particular business or scientific problem that you are solving, and will list the patterns involved in
your proposed solution to the problem, with a brief discussion of how these patterns participate in an intelligent solution to the original
problem. You are free to change your mind, and use other patterns as you get into your coding of the project, as this is the normal course of
software development. Allowing me to review your project concept will give you the go-ahead for proceeding. You should come up with a
legitimate problem concept that will benefit from your selection of patterns (see examples below). That is to say, your pattern selection should
all fit together to solve some legitimate business or scientific need. In short, come up with an interesting problem, and solve it using the
available design, architectural, and enterprise integration patterns. (You may additionally select from any of the patterns in Gamma et. al. for
design patterns and any of the patterns in Hohpe & Woolf). You may leverage Camel's implementations of any of the EIP patterns in your
delivery. You may leverage pattern implementations in Java (that is you may use Java Iterators, etc..., you do not have to write your own
Iterators as you had to do in the labs). You must use both ActiveMQ and Camel in your final deliverable.
Final Project
1/3
Some example project ideas:
1. One might design an auction site that takes in bids from various sources and produces a best bid output, announcing a "winner" after a
certain time. Multiple "auctions" would need to be run concurrently. Possible EIP patterns include Splitter, Aggregator, Message Channel
(Queue or Topic), Message Router, Message Endpoint (from/to), Invalid Message Channel, Content-Based Router, Point-to-Point Channel,
Publish-Subscribe Channel, etc. Possible Design Patterns include Singleton, Template Method (for calculating the winning bid), Iterator to
iterate through lists of auctions or lists of items being auctioned, Strategy (for pricing), etc. You might want to see the example in Hoppe and
Woolf pp. 276ff. for more on an auction example.
2. Or, one might design a portfolio management system that allows multiple/disparate instruments to be valued and displayed to
particular/appropriate customers. Possible EIP patterns include Splitter, Aggregator, Message Channel (Queue or Topic), Message Router, Message Endpoint (from/to), Invalid Message Channel, Content-Based Router, Point-to-Point Channel, Publish-Subscribe Channel, etc.
Possible Design Patterns include Singleton, Composite (for portfolios), Template Method (for calculating the winning bid), Iterator to iterate
through the Composite, Strategy (for pricing strategies, stats calculations, etc.), etc.
3. Or, one might design a typical integration problem where different data formats are shared by different "systems" (these systems can be very
very simple), and leverage a Canonical Data Model to pass messages back and forth between the various "systems". So for example, all
systems pass a trade around, but in one case, the trade is in XML format, in another case, a binary Java object, and in another case, a text file.
The "core" information (price, quantity, buy/sell, etc.) is contained within each system but is provided by the system in different formats.
Possible EIP patterns include Splitter, Aggregator, Message Translator, Message Filter, Message Channel (Queue or Topic), Message Router, Message Endpoint (from/to), Invalid Message Channel, Content-Based Router, Point-to-Point Channel, Publish-Subscribe Channel, etc.
Possible Design Patterns include Singleton, Template Method (for calculating the winning bid), Iterator to iterate through lists of auctions or
lists of items being auctioned, Strategy (for pricing), etc.
4. Or, one might design an RSS Aggregator that reads in multiple RSS feeds and acts on that (big) data. The strategies that might be applied to
the data may range from a fairly simple of aggregation of multiple feeds to one or more channels (like a "Yahoo Business" channel, a "CNN
Headlines" channel, etc.), or something more complicated and challenging that implements big data analytic strategies that may predictive
analytics, crowdsourcing, clustering and distance measurement, association mapping, etc. and puts calculation results onto various channels.
Note you may certainly leverage hadoop and map reduce but you need also to leverage the pattern requirements.
Other (previous) project proposals for the class (which may help you with models for your own proposals) may be found here.
Default Course Project:
If you're having trouble coming up with your own example, you may, if you so choose, use and implement this project idea as your own.
GRADING:
You can "extend" or "reuse" the patterns (and thus your code) used in a lab assignment in your final project, but the reused parts CANNOT be
the primary focus of the project--that is to say, you should not simply "string together" the lab assignments you've already written. Instead,
they can be used as a starting point for developing something new. The reused work should be an order of magnitude less significant than the
final project itself. If you choose to reuse lab work, you give us the license to take off some amount of points if we feel the final project was
not significantly different from the previously-submitted work.
In short, you can "reuse" any pattern(s) that you've used in a given lab, including some of the code.
Also, we need a detailed proposal of about 200 - 600 words (note that these general comments in this web page are about 1200 words) detailing
the following (those who have already been approved do not need to resubmit):
1. The General Topic (1 paragraph)
2. A Description of the Problem to be Solved (1-2 paragraphs)
3. A Listing of the EIP Patterns (6 or more) to be leveraged. HOW and WHY and WHERE?
4. A Listing of the Design Patterns (4 or more) to be leveraged. HOW and WHY and WHERE?
5. A Summary of the anticipated deliverable: About how many classes in the system? About how many source files?
6. A drawing (UML preferred) of your solution
A final project deliverable that is complex enough to make the graders happy should be somewhere between 1000 lines of code or more. Your mileage may vary.
A final note. The focus of the grading of the final project will be on (a) the depth of the problem engaged (b) the quality of your pattern
implementations in your coded solution to that problem more than on the sheer number of lines of code submitted. The above is more of a
guideline. No one will be counting your lines of code. This guideline is for YOU to use as a yardstick to conclude that a submission of 110
lines of Java that has an "AddEmUp" function at its core is probably not going to make anyone happy, most of all yourself.
Final Project
2/3
Final Project
3/3